/******************************************************************************* * Copyright 2012-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. * Licensed under the Apache License, Version 2.0 (the "License"). You may not use * this file except in compliance with the License. A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. * This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR * CONDITIONS OF ANY KIND, either express or implied. See the License for the * specific language governing permissions and limitations under the License. * ***************************************************************************** * * AWS Tools for Windows (TM) PowerShell (TM) * */ using System; using System.Collections.Generic; using System.Linq; using System.Management.Automation; using System.Text; using Amazon.PowerShell.Common; using Amazon.Runtime; using Amazon.CloudWatch; using Amazon.CloudWatch.Model; namespace Amazon.PowerShell.Cmdlets.CW { /// /// Creates or updates an alarm and associates it with the specified metric, metric math /// expression, anomaly detection model, or Metrics Insights query. For more information /// about using a Metrics Insights query for an alarm, see Create /// alarms on Metrics Insights queries. /// /// /// /// Alarms based on anomaly detection models cannot have Auto Scaling actions. /// /// When this operation creates an alarm, the alarm state is immediately set to INSUFFICIENT_DATA. /// The alarm is then evaluated and its state is set appropriately. Any actions associated /// with the new state are then executed. /// /// When you update an existing alarm, its state is left unchanged, but the update completely /// overwrites the previous configuration of the alarm. /// /// If you are an IAM user, you must have Amazon EC2 permissions for some alarm operations: /// /// The first time you create an alarm in the Amazon Web Services Management Console, /// the CLI, or by using the PutMetricAlarm API, CloudWatch creates the necessary service-linked /// role for you. The service-linked roles are called AWSServiceRoleForCloudWatchEvents /// and AWSServiceRoleForCloudWatchAlarms_ActionSSM. For more information, /// see Amazon /// Web Services service-linked role. /// /// Each PutMetricAlarm action has a maximum uncompressed payload of 120 /// KB. /// Cross-account alarms /// You can set an alarm on metrics in the current account, or in another account. To /// create a cross-account alarm that watches a metric in a different account, you must /// have completed the following pre-requisites: /// /// [Cmdlet("Write", "CWMetricAlarm", SupportsShouldProcess = true, ConfirmImpact = ConfirmImpact.Medium)] [OutputType("None")] [AWSCmdlet("Calls the Amazon CloudWatch PutMetricAlarm API operation.", Operation = new[] {"PutMetricAlarm"}, SelectReturnType = typeof(Amazon.CloudWatch.Model.PutMetricAlarmResponse))] [AWSCmdletOutput("None or Amazon.CloudWatch.Model.PutMetricAlarmResponse", "This cmdlet does not generate any output." + "The service response (type Amazon.CloudWatch.Model.PutMetricAlarmResponse) can be referenced from properties attached to the cmdlet entry in the $AWSHistory stack." )] public partial class WriteCWMetricAlarmCmdlet : AmazonCloudWatchClientCmdlet, IExecutor { #region Parameter ActionsEnabled /// /// /// Indicates whether actions should be executed during any changes to the alarm state. /// The default is TRUE. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Boolean? ActionsEnabled { get; set; } #endregion #region Parameter AlarmAction /// /// /// The actions to execute when this alarm transitions to the ALARM state /// from any other state. Each action is specified as an Amazon Resource Name (ARN). Valid /// values:EC2 actions:Autoscaling action:SNS notification action:SSM integration actions: /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("AlarmActions")] public System.String[] AlarmAction { get; set; } #endregion #region Parameter AlarmDescription /// /// /// The description for the alarm. /// /// [System.Management.Automation.Parameter(Position = 1, ValueFromPipelineByPropertyName = true)] public System.String AlarmDescription { get; set; } #endregion #region Parameter AlarmName /// /// /// The name for the alarm. This name must be unique within the Region.The name must contain only UTF-8 characters, and can't contain ASCII control characters /// /// #if !MODULAR [System.Management.Automation.Parameter(Position = 0, ValueFromPipelineByPropertyName = true, ValueFromPipeline = true)] #else [System.Management.Automation.Parameter(Position = 0, ValueFromPipelineByPropertyName = true, ValueFromPipeline = true, Mandatory = true)] [System.Management.Automation.AllowEmptyString] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] public System.String AlarmName { get; set; } #endregion #region Parameter ComparisonOperator /// /// /// The arithmetic operation to use when comparing the specified statistic and threshold. /// The specified statistic value is used as the first operand.The values LessThanLowerOrGreaterThanUpperThreshold, LessThanLowerThreshold, /// and GreaterThanUpperThreshold are used only for alarms based on anomaly /// detection models. /// /// #if !MODULAR [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] #else [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] [AWSConstantClassSource("Amazon.CloudWatch.ComparisonOperator")] public Amazon.CloudWatch.ComparisonOperator ComparisonOperator { get; set; } #endregion #region Parameter DatapointsToAlarm /// /// /// The number of data points that must be breaching to trigger the alarm. This is used /// only if you are setting an "M out of N" alarm. In that case, this value is the M. /// For more information, see Evaluating /// an Alarm in the Amazon CloudWatch User Guide. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Int32? DatapointsToAlarm { get; set; } #endregion #region Parameter Dimension /// /// /// The dimensions for the metric specified in MetricName. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("Dimensions")] public Amazon.CloudWatch.Model.Dimension[] Dimension { get; set; } #endregion #region Parameter EvaluateLowSampleCountPercentile /// /// /// Used only for alarms based on percentiles. If you specify ignore, the /// alarm state does not change during periods with too few data points to be statistically /// significant. If you specify evaluate or omit this parameter, the alarm /// is always evaluated and possibly changes state no matter how many data points are /// available. For more information, see Percentile-Based /// CloudWatch Alarms and Low Data Samples.Valid Values: evaluate | ignore /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String EvaluateLowSampleCountPercentile { get; set; } #endregion #region Parameter EvaluationPeriod /// /// /// The number of periods over which data is compared to the specified threshold. If you /// are setting an alarm that requires that a number of consecutive data points be breaching /// to trigger the alarm, this value specifies that number. If you are setting an "M out /// of N" alarm, this value is the N.An alarm's total current evaluation period can be no longer than one day, so this /// number multiplied by Period cannot be more than 86,400 seconds. /// /// #if !MODULAR [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] #else [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] [Alias("EvaluationPeriods")] public System.Int32? EvaluationPeriod { get; set; } #endregion #region Parameter ExtendedStatistic /// /// /// The percentile statistic for the metric specified in MetricName. Specify /// a value between p0.0 and p100. When you call PutMetricAlarm and specify /// a MetricName, you must specify either Statistic or ExtendedStatistic, /// but not both. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String ExtendedStatistic { get; set; } #endregion #region Parameter InsufficientDataAction /// /// /// The actions to execute when this alarm transitions to the INSUFFICIENT_DATA /// state from any other state. Each action is specified as an Amazon Resource Name (ARN). /// Valid values:EC2 actions:Autoscaling action:SNS notification action:SSM integration actions: /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("InsufficientDataActions")] public System.String[] InsufficientDataAction { get; set; } #endregion #region Parameter MetricName /// /// /// The name for the metric associated with the alarm. For each PutMetricAlarm /// operation, you must specify either MetricName or a Metrics /// array.If you are creating an alarm based on a math expression, you cannot specify this parameter, /// or any of the Dimensions, Period, Namespace, /// Statistic, or ExtendedStatistic parameters. Instead, you /// specify all this information in the Metrics array. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String MetricName { get; set; } #endregion #region Parameter Metric /// /// /// An array of MetricDataQuery structures that enable you to create an alarm /// based on the result of a metric math expression. For each PutMetricAlarm /// operation, you must specify either MetricName or a Metrics /// array.Each item in the Metrics array either retrieves a metric or performs /// a math expression.One item in the Metrics array is the expression that the alarm watches. /// You designate this expression by setting ReturnData to true for this /// object in the array. For more information, see MetricDataQuery.If you use the Metrics parameter, you cannot include the MetricName, /// Dimensions, Period, Namespace, Statistic, /// or ExtendedStatistic parameters of PutMetricAlarm in the /// same operation. Instead, you retrieve the metrics you are using in your math expression /// as part of the Metrics array. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("Metrics")] public Amazon.CloudWatch.Model.MetricDataQuery[] Metric { get; set; } #endregion #region Parameter Namespace /// /// /// The namespace for the metric associated specified in MetricName. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Namespace { get; set; } #endregion #region Parameter OKAction /// /// /// The actions to execute when this alarm transitions to an OK state from /// any other state. Each action is specified as an Amazon Resource Name (ARN). Valid /// values:EC2 actions:Autoscaling action:SNS notification action:SSM integration actions: /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("OKActions")] public System.String[] OKAction { get; set; } #endregion #region Parameter Period /// /// /// The length, in seconds, used each time the metric specified in MetricName /// is evaluated. Valid values are 10, 30, and any multiple of 60.Period is required for alarms based on static thresholds. If you are /// creating an alarm based on a metric math expression, you specify the period for each /// metric within the objects in the Metrics array.Be sure to specify 10 or 30 only for metrics that are stored by a PutMetricData /// call with a StorageResolution of 1. If you specify a period of 10 or /// 30 for a metric that does not have sub-minute resolution, the alarm still attempts /// to gather data at the period rate that you specify. In this case, it does not receive /// data for the attempts that do not correspond to a one-minute data resolution, and /// the alarm might often lapse into INSUFFICENT_DATA status. Specifying 10 or 30 also /// sets this alarm as a high-resolution alarm, which has a higher charge than other alarms. /// For more information about pricing, see Amazon /// CloudWatch Pricing.An alarm's total current evaluation period can be no longer than one day, so Period /// multiplied by EvaluationPeriods cannot be more than 86,400 seconds. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Int32? Period { get; set; } #endregion #region Parameter Statistic /// /// /// The statistic for the metric specified in MetricName, other than percentile. /// For percentile statistics, use ExtendedStatistic. When you call PutMetricAlarm /// and specify a MetricName, you must specify either Statistic /// or ExtendedStatistic, but not both. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [AWSConstantClassSource("Amazon.CloudWatch.Statistic")] public Amazon.CloudWatch.Statistic Statistic { get; set; } #endregion #region Parameter Tag /// /// /// A list of key-value pairs to associate with the alarm. You can associate as many as /// 50 tags with an alarm.Tags can help you organize and categorize your resources. You can also use them to /// scope user permissions by granting a user permission to access or change only resources /// with certain tag values.If you are using this operation to update an existing alarm, any tags you specify /// in this parameter are ignored. To change the tags of an existing alarm, use TagResource /// or UntagResource. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("Tags")] public Amazon.CloudWatch.Model.Tag[] Tag { get; set; } #endregion #region Parameter Threshold /// /// /// The value against which the specified statistic is compared.This parameter is required for alarms based on static thresholds, but should not be /// used for alarms based on anomaly detection models. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Double? Threshold { get; set; } #endregion #region Parameter ThresholdMetricId /// /// /// If this is an alarm based on an anomaly detection model, make this value match the /// ID of the ANOMALY_DETECTION_BAND function.For an example of how to use this parameter, see the Anomaly Detection Model Alarm /// example on this page.If your alarm uses this parameter, it cannot have Auto Scaling actions. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String ThresholdMetricId { get; set; } #endregion #region Parameter TreatMissingData /// /// /// Sets how this alarm is to handle missing data points. If TreatMissingData /// is omitted, the default behavior of missing is used. For more information, /// see Configuring /// How CloudWatch Alarms Treats Missing Data.Valid Values: breaching | notBreaching | ignore | missingAlarms that evaluate metrics in the AWS/DynamoDB namespace always ignore /// missing data even if you choose a different option for TreatMissingData. /// When an AWS/DynamoDB metric has missing data, alarms that evaluate that /// metric remain in their current state. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String TreatMissingData { get; set; } #endregion #region Parameter Unit /// /// /// The unit of measure for the statistic. For example, the units for the Amazon EC2 NetworkIn /// metric are Bytes because NetworkIn tracks the number of bytes that an instance receives /// on all network interfaces. You can also specify a unit when you create a custom metric. /// Units help provide conceptual meaning to your data. Metric data points that specify /// a unit of measure, such as Percent, are aggregated separately.If you don't specify Unit, CloudWatch retrieves all unit types that have /// been published for the metric and attempts to evaluate the alarm. Usually, metrics /// are published with only one unit, so the alarm works as intended.However, if the metric is published with multiple types of units and you don't specify /// a unit, the alarm's behavior is not defined and it behaves unpredictably.We recommend omitting Unit so that you don't inadvertently specify an /// incorrect unit that is not published for this metric. Doing so causes the alarm to /// be stuck in the INSUFFICIENT DATA state. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [AWSConstantClassSource("Amazon.CloudWatch.StandardUnit")] public Amazon.CloudWatch.StandardUnit Unit { get; set; } #endregion #region Parameter Select /// /// Use the -Select parameter to control the cmdlet output. The cmdlet doesn't have a return value by default. /// Specifying -Select '*' will result in the cmdlet returning the whole service response (Amazon.CloudWatch.Model.PutMetricAlarmResponse). /// Specifying -Select '^ParameterName' will result in the cmdlet returning the selected cmdlet parameter value. /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public string Select { get; set; } = "*"; #endregion #region Parameter PassThru /// /// Changes the cmdlet behavior to return the value passed to the AlarmName parameter. /// The -PassThru parameter is deprecated, use -Select '^AlarmName' instead. This parameter will be removed in a future version. /// [System.Obsolete("The -PassThru parameter is deprecated, use -Select '^AlarmName' instead. This parameter will be removed in a future version.")] [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public SwitchParameter PassThru { get; set; } #endregion #region Parameter Force /// /// This parameter overrides confirmation prompts to force /// the cmdlet to continue its operation. This parameter should always /// be used with caution. /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public SwitchParameter Force { get; set; } #endregion protected override void ProcessRecord() { this._AWSSignerType = "v4"; base.ProcessRecord(); var resourceIdentifiersText = FormatParameterValuesForConfirmationMsg(nameof(this.AlarmName), MyInvocation.BoundParameters); if (!ConfirmShouldProceed(this.Force.IsPresent, resourceIdentifiersText, "Write-CWMetricAlarm (PutMetricAlarm)")) { return; } var context = new CmdletContext(); // allow for manipulation of parameters prior to loading into context PreExecutionContextLoad(context); #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute if (ParameterWasBound(nameof(this.Select))) { context.Select = CreateSelectDelegate(Select) ?? throw new System.ArgumentException("Invalid value for -Select parameter.", nameof(this.Select)); if (this.PassThru.IsPresent) { throw new System.ArgumentException("-PassThru cannot be used when -Select is specified.", nameof(this.Select)); } } else if (this.PassThru.IsPresent) { context.Select = (response, cmdlet) => this.AlarmName; } #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute context.ActionsEnabled = this.ActionsEnabled; if (this.AlarmAction != null) { context.AlarmAction = new List(this.AlarmAction); } context.AlarmDescription = this.AlarmDescription; context.AlarmName = this.AlarmName; #if MODULAR if (this.AlarmName == null && ParameterWasBound(nameof(this.AlarmName))) { WriteWarning("You are passing $null as a value for parameter AlarmName which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.ComparisonOperator = this.ComparisonOperator; #if MODULAR if (this.ComparisonOperator == null && ParameterWasBound(nameof(this.ComparisonOperator))) { WriteWarning("You are passing $null as a value for parameter ComparisonOperator which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.DatapointsToAlarm = this.DatapointsToAlarm; if (this.Dimension != null) { context.Dimension = new List(this.Dimension); } context.EvaluateLowSampleCountPercentile = this.EvaluateLowSampleCountPercentile; context.EvaluationPeriod = this.EvaluationPeriod; #if MODULAR if (this.EvaluationPeriod == null && ParameterWasBound(nameof(this.EvaluationPeriod))) { WriteWarning("You are passing $null as a value for parameter EvaluationPeriod which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.ExtendedStatistic = this.ExtendedStatistic; if (this.InsufficientDataAction != null) { context.InsufficientDataAction = new List(this.InsufficientDataAction); } context.MetricName = this.MetricName; if (this.Metric != null) { context.Metric = new List(this.Metric); } context.Namespace = this.Namespace; if (this.OKAction != null) { context.OKAction = new List(this.OKAction); } context.Period = this.Period; context.Statistic = this.Statistic; if (this.Tag != null) { context.Tag = new List(this.Tag); } context.Threshold = this.Threshold; context.ThresholdMetricId = this.ThresholdMetricId; context.TreatMissingData = this.TreatMissingData; context.Unit = this.Unit; // allow further manipulation of loaded context prior to processing PostExecutionContextLoad(context); var output = Execute(context) as CmdletOutput; ProcessOutput(output); } #region IExecutor Members public object Execute(ExecutorContext context) { var cmdletContext = context as CmdletContext; // create request var request = new Amazon.CloudWatch.Model.PutMetricAlarmRequest(); if (cmdletContext.ActionsEnabled != null) { request.ActionsEnabled = cmdletContext.ActionsEnabled.Value; } if (cmdletContext.AlarmAction != null) { request.AlarmActions = cmdletContext.AlarmAction; } if (cmdletContext.AlarmDescription != null) { request.AlarmDescription = cmdletContext.AlarmDescription; } if (cmdletContext.AlarmName != null) { request.AlarmName = cmdletContext.AlarmName; } if (cmdletContext.ComparisonOperator != null) { request.ComparisonOperator = cmdletContext.ComparisonOperator; } if (cmdletContext.DatapointsToAlarm != null) { request.DatapointsToAlarm = cmdletContext.DatapointsToAlarm.Value; } if (cmdletContext.Dimension != null) { request.Dimensions = cmdletContext.Dimension; } if (cmdletContext.EvaluateLowSampleCountPercentile != null) { request.EvaluateLowSampleCountPercentile = cmdletContext.EvaluateLowSampleCountPercentile; } if (cmdletContext.EvaluationPeriod != null) { request.EvaluationPeriods = cmdletContext.EvaluationPeriod.Value; } if (cmdletContext.ExtendedStatistic != null) { request.ExtendedStatistic = cmdletContext.ExtendedStatistic; } if (cmdletContext.InsufficientDataAction != null) { request.InsufficientDataActions = cmdletContext.InsufficientDataAction; } if (cmdletContext.MetricName != null) { request.MetricName = cmdletContext.MetricName; } if (cmdletContext.Metric != null) { request.Metrics = cmdletContext.Metric; } if (cmdletContext.Namespace != null) { request.Namespace = cmdletContext.Namespace; } if (cmdletContext.OKAction != null) { request.OKActions = cmdletContext.OKAction; } if (cmdletContext.Period != null) { request.Period = cmdletContext.Period.Value; } if (cmdletContext.Statistic != null) { request.Statistic = cmdletContext.Statistic; } if (cmdletContext.Tag != null) { request.Tags = cmdletContext.Tag; } if (cmdletContext.Threshold != null) { request.Threshold = cmdletContext.Threshold.Value; } if (cmdletContext.ThresholdMetricId != null) { request.ThresholdMetricId = cmdletContext.ThresholdMetricId; } if (cmdletContext.TreatMissingData != null) { request.TreatMissingData = cmdletContext.TreatMissingData; } if (cmdletContext.Unit != null) { request.Unit = cmdletContext.Unit; } CmdletOutput output; // issue call var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint); try { var response = CallAWSServiceOperation(client, request); object pipelineOutput = null; pipelineOutput = cmdletContext.Select(response, this); output = new CmdletOutput { PipelineOutput = pipelineOutput, ServiceResponse = response }; } catch (Exception e) { output = new CmdletOutput { ErrorResponse = e }; } return output; } public ExecutorContext CreateContext() { return new CmdletContext(); } #endregion #region AWS Service Operation Call private Amazon.CloudWatch.Model.PutMetricAlarmResponse CallAWSServiceOperation(IAmazonCloudWatch client, Amazon.CloudWatch.Model.PutMetricAlarmRequest request) { Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon CloudWatch", "PutMetricAlarm"); try { #if DESKTOP return client.PutMetricAlarm(request); #elif CORECLR return client.PutMetricAlarmAsync(request).GetAwaiter().GetResult(); #else #error "Unknown build edition" #endif } catch (AmazonServiceException exc) { var webException = exc.InnerException as System.Net.WebException; if (webException != null) { throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException); } throw; } } #endregion internal partial class CmdletContext : ExecutorContext { public System.Boolean? ActionsEnabled { get; set; } public List AlarmAction { get; set; } public System.String AlarmDescription { get; set; } public System.String AlarmName { get; set; } public Amazon.CloudWatch.ComparisonOperator ComparisonOperator { get; set; } public System.Int32? DatapointsToAlarm { get; set; } public List Dimension { get; set; } public System.String EvaluateLowSampleCountPercentile { get; set; } public System.Int32? EvaluationPeriod { get; set; } public System.String ExtendedStatistic { get; set; } public List InsufficientDataAction { get; set; } public System.String MetricName { get; set; } public List Metric { get; set; } public System.String Namespace { get; set; } public List OKAction { get; set; } public System.Int32? Period { get; set; } public Amazon.CloudWatch.Statistic Statistic { get; set; } public List Tag { get; set; } public System.Double? Threshold { get; set; } public System.String ThresholdMetricId { get; set; } public System.String TreatMissingData { get; set; } public Amazon.CloudWatch.StandardUnit Unit { get; set; } public System.Func Select { get; set; } = (response, cmdlet) => null; } } }