aws-cdk-lib 2.145.0__py3-none-any.whl → 2.147.0__py3-none-any.whl

aws_cdk/aws_autoscaling/__init__.py

@@ -8375,15 +8375,37 @@ class CfnScalingPolicy(
         
                 # the properties below are optional
                 customized_metric_specification=autoscaling.CfnScalingPolicy.CustomizedMetricSpecificationProperty(
-                    metric_name="metricName",
-                    namespace="namespace",
-                    statistic="statistic",
-        
-                    # the properties below are optional
                     dimensions=[autoscaling.CfnScalingPolicy.MetricDimensionProperty(
                         name="name",
                         value="value"
                     )],
+                    metric_name="metricName",
+                    metrics=[autoscaling.CfnScalingPolicy.TargetTrackingMetricDataQueryProperty(
+                        id="id",
+        
+                        # the properties below are optional
+                        expression="expression",
+                        label="label",
+                        metric_stat=autoscaling.CfnScalingPolicy.TargetTrackingMetricStatProperty(
+                            metric=autoscaling.CfnScalingPolicy.MetricProperty(
+                                metric_name="metricName",
+                                namespace="namespace",
+        
+                                # the properties below are optional
+                                dimensions=[autoscaling.CfnScalingPolicy.MetricDimensionProperty(
+                                    name="name",
+                                    value="value"
+                                )]
+                            ),
+                            stat="stat",
+        
+                            # the properties below are optional
+                            unit="unit"
+                        ),
+                        return_data=False
+                    )],
+                    namespace="namespace",
+                    statistic="statistic",
                     unit="unit"
                 ),
                 disable_scale_in=False,
@@ -8670,10 +8692,11 @@ class CfnScalingPolicy(
         jsii_type="aws-cdk-lib.aws_autoscaling.CfnScalingPolicy.CustomizedMetricSpecificationProperty",
         jsii_struct_bases=[],
         name_mapping={
+            "dimensions": "dimensions",
             "metric_name": "metricName",
+            "metrics": "metrics",
             "namespace": "namespace",
             "statistic": "statistic",
-            "dimensions": "dimensions",
             "unit": "unit",
         },
     )
@@ -8681,10 +8704,11 @@ class CfnScalingPolicy(
         def __init__(
             self,
             *,
-            metric_name: builtins.str,
-            namespace: builtins.str,
-            statistic: builtins.str,
             dimensions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnScalingPolicy.MetricDimensionProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
+            metric_name: typing.Optional[builtins.str] = None,
+            metrics: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnScalingPolicy.TargetTrackingMetricDataQueryProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
+            namespace: typing.Optional[builtins.str] = None,
+            statistic: typing.Optional[builtins.str] = None,
             unit: typing.Optional[builtins.str] = None,
         ) -> None:
             '''Contains customized metric specification information for a target tracking scaling policy for Amazon EC2 Auto Scaling.
@@ -8698,10 +8722,11 @@ class CfnScalingPolicy(
 
             ``CustomizedMetricSpecification`` is a property of the `AWS::AutoScaling::ScalingPolicy TargetTrackingConfiguration <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-targettrackingconfiguration.html>`_ property type.
 
+            :param dimensions: The dimensions of the metric. Conditional: If you published your metric with dimensions, you must specify the same dimensions in your scaling policy.
             :param metric_name: The name of the metric. To get the exact metric name, namespace, and dimensions, inspect the `Metric <https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_Metric.html>`_ object that is returned by a call to `ListMetrics <https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_ListMetrics.html>`_ .
+            :param metrics: The metrics to include in the target tracking scaling policy, as a metric data query. This can include both raw metric and metric math expressions.
             :param namespace: The namespace of the metric.
             :param statistic: The statistic of the metric.
-            :param dimensions: The dimensions of the metric. Conditional: If you published your metric with dimensions, you must specify the same dimensions in your scaling policy.
             :param unit: The unit of the metric. For a complete list of the units that CloudWatch supports, see the `MetricDatum <https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html>`_ data type in the *Amazon CloudWatch API Reference* .
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-customizedmetricspecification.html
@@ -8714,37 +8739,77 @@ class CfnScalingPolicy(
                 from aws_cdk import aws_autoscaling as autoscaling
                 
                 customized_metric_specification_property = autoscaling.CfnScalingPolicy.CustomizedMetricSpecificationProperty(
-                    metric_name="metricName",
-                    namespace="namespace",
-                    statistic="statistic",
-                
-                    # the properties below are optional
                     dimensions=[autoscaling.CfnScalingPolicy.MetricDimensionProperty(
                         name="name",
                         value="value"
                     )],
+                    metric_name="metricName",
+                    metrics=[autoscaling.CfnScalingPolicy.TargetTrackingMetricDataQueryProperty(
+                        id="id",
+                
+                        # the properties below are optional
+                        expression="expression",
+                        label="label",
+                        metric_stat=autoscaling.CfnScalingPolicy.TargetTrackingMetricStatProperty(
+                            metric=autoscaling.CfnScalingPolicy.MetricProperty(
+                                metric_name="metricName",
+                                namespace="namespace",
+                
+                                # the properties below are optional
+                                dimensions=[autoscaling.CfnScalingPolicy.MetricDimensionProperty(
+                                    name="name",
+                                    value="value"
+                                )]
+                            ),
+                            stat="stat",
+                
+                            # the properties below are optional
+                            unit="unit"
+                        ),
+                        return_data=False
+                    )],
+                    namespace="namespace",
+                    statistic="statistic",
                     unit="unit"
                 )
             '''
             if __debug__:
                 type_hints = typing.get_type_hints(_typecheckingstub__8e7031340719d237d3182678de0dc2931e386340d37c2dd60e36be75ada41bb3)
+                check_type(argname="argument dimensions", value=dimensions, expected_type=type_hints["dimensions"])
                 check_type(argname="argument metric_name", value=metric_name, expected_type=type_hints["metric_name"])
+                check_type(argname="argument metrics", value=metrics, expected_type=type_hints["metrics"])
                 check_type(argname="argument namespace", value=namespace, expected_type=type_hints["namespace"])
                 check_type(argname="argument statistic", value=statistic, expected_type=type_hints["statistic"])
-                check_type(argname="argument dimensions", value=dimensions, expected_type=type_hints["dimensions"])
                 check_type(argname="argument unit", value=unit, expected_type=type_hints["unit"])
-            self._values: typing.Dict[builtins.str, typing.Any] = {
-                "metric_name": metric_name,
-                "namespace": namespace,
-                "statistic": statistic,
-            }
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
             if dimensions is not None:
                 self._values["dimensions"] = dimensions
+            if metric_name is not None:
+                self._values["metric_name"] = metric_name
+            if metrics is not None:
+                self._values["metrics"] = metrics
+            if namespace is not None:
+                self._values["namespace"] = namespace
+            if statistic is not None:
+                self._values["statistic"] = statistic
             if unit is not None:
                 self._values["unit"] = unit
 
         @builtins.property
-        def metric_name(self) -> builtins.str:
+        def dimensions(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnScalingPolicy.MetricDimensionProperty"]]]]:
+            '''The dimensions of the metric.
+
+            Conditional: If you published your metric with dimensions, you must specify the same dimensions in your scaling policy.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-customizedmetricspecification.html#cfn-autoscaling-scalingpolicy-customizedmetricspecification-dimensions
+            '''
+            result = self._values.get("dimensions")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnScalingPolicy.MetricDimensionProperty"]]]], result)
+
+        @builtins.property
+        def metric_name(self) -> typing.Optional[builtins.str]:
             '''The name of the metric.
 
             To get the exact metric name, namespace, and dimensions, inspect the `Metric <https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_Metric.html>`_ object that is returned by a call to `ListMetrics <https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_ListMetrics.html>`_ .
@@ -8752,41 +8817,38 @@ class CfnScalingPolicy(
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-customizedmetricspecification.html#cfn-autoscaling-scalingpolicy-customizedmetricspecification-metricname
             '''
             result = self._values.get("metric_name")
-            assert result is not None, "Required property 'metric_name' is missing"
-            return typing.cast(builtins.str, result)
+            return typing.cast(typing.Optional[builtins.str], result)
 
         @builtins.property
-        def namespace(self) -> builtins.str:
+        def metrics(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnScalingPolicy.TargetTrackingMetricDataQueryProperty"]]]]:
+            '''The metrics to include in the target tracking scaling policy, as a metric data query.
+
+            This can include both raw metric and metric math expressions.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-customizedmetricspecification.html#cfn-autoscaling-scalingpolicy-customizedmetricspecification-metrics
+            '''
+            result = self._values.get("metrics")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnScalingPolicy.TargetTrackingMetricDataQueryProperty"]]]], result)
+
+        @builtins.property
+        def namespace(self) -> typing.Optional[builtins.str]:
             '''The namespace of the metric.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-customizedmetricspecification.html#cfn-autoscaling-scalingpolicy-customizedmetricspecification-namespace
             '''
             result = self._values.get("namespace")
-            assert result is not None, "Required property 'namespace' is missing"
-            return typing.cast(builtins.str, result)
+            return typing.cast(typing.Optional[builtins.str], result)
 
         @builtins.property
-        def statistic(self) -> builtins.str:
+        def statistic(self) -> typing.Optional[builtins.str]:
             '''The statistic of the metric.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-customizedmetricspecification.html#cfn-autoscaling-scalingpolicy-customizedmetricspecification-statistic
             '''
             result = self._values.get("statistic")
-            assert result is not None, "Required property 'statistic' is missing"
-            return typing.cast(builtins.str, result)
-
-        @builtins.property
-        def dimensions(
-            self,
-        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnScalingPolicy.MetricDimensionProperty"]]]]:
-            '''The dimensions of the metric.
-
-            Conditional: If you published your metric with dimensions, you must specify the same dimensions in your scaling policy.
-
-            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-customizedmetricspecification.html#cfn-autoscaling-scalingpolicy-customizedmetricspecification-dimensions
-            '''
-            result = self._values.get("dimensions")
-            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnScalingPolicy.MetricDimensionProperty"]]]], result)
+            return typing.cast(typing.Optional[builtins.str], result)
 
         @builtins.property
         def unit(self) -> typing.Optional[builtins.str]:
@@ -10572,15 +10634,37 @@ class CfnScalingPolicy(
                 
                     # the properties below are optional
                     customized_metric_specification=autoscaling.CfnScalingPolicy.CustomizedMetricSpecificationProperty(
-                        metric_name="metricName",
-                        namespace="namespace",
-                        statistic="statistic",
-                
-                        # the properties below are optional
                         dimensions=[autoscaling.CfnScalingPolicy.MetricDimensionProperty(
                             name="name",
                             value="value"
                         )],
+                        metric_name="metricName",
+                        metrics=[autoscaling.CfnScalingPolicy.TargetTrackingMetricDataQueryProperty(
+                            id="id",
+                
+                            # the properties below are optional
+                            expression="expression",
+                            label="label",
+                            metric_stat=autoscaling.CfnScalingPolicy.TargetTrackingMetricStatProperty(
+                                metric=autoscaling.CfnScalingPolicy.MetricProperty(
+                                    metric_name="metricName",
+                                    namespace="namespace",
+                
+                                    # the properties below are optional
+                                    dimensions=[autoscaling.CfnScalingPolicy.MetricDimensionProperty(
+                                        name="name",
+                                        value="value"
+                                    )]
+                                ),
+                                stat="stat",
+                
+                                # the properties below are optional
+                                unit="unit"
+                            ),
+                            return_data=False
+                        )],
+                        namespace="namespace",
+                        statistic="statistic",
                         unit="unit"
                     ),
                     disable_scale_in=False,
@@ -10672,6 +10756,280 @@ class CfnScalingPolicy(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_autoscaling.CfnScalingPolicy.TargetTrackingMetricDataQueryProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "id": "id",
+            "expression": "expression",
+            "label": "label",
+            "metric_stat": "metricStat",
+            "return_data": "returnData",
+        },
+    )
+    class TargetTrackingMetricDataQueryProperty:
+        def __init__(
+            self,
+            *,
+            id: builtins.str,
+            expression: typing.Optional[builtins.str] = None,
+            label: typing.Optional[builtins.str] = None,
+            metric_stat: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnScalingPolicy.TargetTrackingMetricStatProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            return_data: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+        ) -> None:
+            '''The metric data to return.
+
+            Also defines whether this call is returning data for one metric only, or whether it is performing a math expression on the values of returned metric statistics to create a new time series. A time series is a series of data points, each of which is associated with a timestamp.
+
+            ``TargetTrackingMetricDataQuery`` is used with the `AWS::AutoScaling::ScalingPolicy CustomizedMetricSpecification <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-customizedmetricspecification.html>`_ property type.
+
+            You can call for a single metric or perform math expressions on multiple metrics. Any expressions used in a metric specification must eventually return a single time series.
+
+            For more information, see the `Create a target tracking scaling policy for Amazon EC2 Auto Scaling using metric math <https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-target-tracking-metric-math.html>`_ in the *Amazon EC2 Auto Scaling User Guide* .
+
+            :param id: A short name that identifies the object's results in the response. This name must be unique among all ``TargetTrackingMetricDataQuery`` objects specified for a single scaling policy. If you are performing math expressions on this set of data, this name represents that data and can serve as a variable in the mathematical expression. The valid characters are letters, numbers, and underscores. The first character must be a lowercase letter.
+            :param expression: The math expression to perform on the returned data, if this object is performing a math expression. This expression can use the ``Id`` of the other metrics to refer to those metrics, and can also use the ``Id`` of other expressions to use the result of those expressions. Conditional: Within each ``TargetTrackingMetricDataQuery`` object, you must specify either ``Expression`` or ``MetricStat`` , but not both.
+            :param label: A human-readable label for this metric or expression. This is especially useful if this is a math expression, so that you know what the value represents.
+            :param metric_stat: Information about the metric data to return. Conditional: Within each ``TargetTrackingMetricDataQuery`` object, you must specify either ``Expression`` or ``MetricStat`` , but not both.
+            :param return_data: Indicates whether to return the timestamps and raw data values of this metric. If you use any math expressions, specify ``true`` for this value for only the final math expression that the metric specification is based on. You must specify ``false`` for ``ReturnData`` for all the other metrics and expressions used in the metric specification. If you are only retrieving metrics and not performing any math expressions, do not specify anything for ``ReturnData`` . This sets it to its default ( ``true`` ).
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-targettrackingmetricdataquery.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_autoscaling as autoscaling
+                
+                target_tracking_metric_data_query_property = autoscaling.CfnScalingPolicy.TargetTrackingMetricDataQueryProperty(
+                    id="id",
+                
+                    # the properties below are optional
+                    expression="expression",
+                    label="label",
+                    metric_stat=autoscaling.CfnScalingPolicy.TargetTrackingMetricStatProperty(
+                        metric=autoscaling.CfnScalingPolicy.MetricProperty(
+                            metric_name="metricName",
+                            namespace="namespace",
+                
+                            # the properties below are optional
+                            dimensions=[autoscaling.CfnScalingPolicy.MetricDimensionProperty(
+                                name="name",
+                                value="value"
+                            )]
+                        ),
+                        stat="stat",
+                
+                        # the properties below are optional
+                        unit="unit"
+                    ),
+                    return_data=False
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__db2b2d9653863b1d1b8f67347857edde6d9dc3f6f755a593d8da143f90fe6fe7)
+                check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+                check_type(argname="argument expression", value=expression, expected_type=type_hints["expression"])
+                check_type(argname="argument label", value=label, expected_type=type_hints["label"])
+                check_type(argname="argument metric_stat", value=metric_stat, expected_type=type_hints["metric_stat"])
+                check_type(argname="argument return_data", value=return_data, expected_type=type_hints["return_data"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "id": id,
+            }
+            if expression is not None:
+                self._values["expression"] = expression
+            if label is not None:
+                self._values["label"] = label
+            if metric_stat is not None:
+                self._values["metric_stat"] = metric_stat
+            if return_data is not None:
+                self._values["return_data"] = return_data
+
+        @builtins.property
+        def id(self) -> builtins.str:
+            '''A short name that identifies the object's results in the response.
+
+            This name must be unique among all ``TargetTrackingMetricDataQuery`` objects specified for a single scaling policy. If you are performing math expressions on this set of data, this name represents that data and can serve as a variable in the mathematical expression. The valid characters are letters, numbers, and underscores. The first character must be a lowercase letter.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-targettrackingmetricdataquery.html#cfn-autoscaling-scalingpolicy-targettrackingmetricdataquery-id
+            '''
+            result = self._values.get("id")
+            assert result is not None, "Required property 'id' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def expression(self) -> typing.Optional[builtins.str]:
+            '''The math expression to perform on the returned data, if this object is performing a math expression.
+
+            This expression can use the ``Id`` of the other metrics to refer to those metrics, and can also use the ``Id`` of other expressions to use the result of those expressions.
+
+            Conditional: Within each ``TargetTrackingMetricDataQuery`` object, you must specify either ``Expression`` or ``MetricStat`` , but not both.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-targettrackingmetricdataquery.html#cfn-autoscaling-scalingpolicy-targettrackingmetricdataquery-expression
+            '''
+            result = self._values.get("expression")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def label(self) -> typing.Optional[builtins.str]:
+            '''A human-readable label for this metric or expression.
+
+            This is especially useful if this is a math expression, so that you know what the value represents.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-targettrackingmetricdataquery.html#cfn-autoscaling-scalingpolicy-targettrackingmetricdataquery-label
+            '''
+            result = self._values.get("label")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def metric_stat(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnScalingPolicy.TargetTrackingMetricStatProperty"]]:
+            '''Information about the metric data to return.
+
+            Conditional: Within each ``TargetTrackingMetricDataQuery`` object, you must specify either ``Expression`` or ``MetricStat`` , but not both.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-targettrackingmetricdataquery.html#cfn-autoscaling-scalingpolicy-targettrackingmetricdataquery-metricstat
+            '''
+            result = self._values.get("metric_stat")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnScalingPolicy.TargetTrackingMetricStatProperty"]], result)
+
+        @builtins.property
+        def return_data(
+            self,
+        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+            '''Indicates whether to return the timestamps and raw data values of this metric.
+
+            If you use any math expressions, specify ``true`` for this value for only the final math expression that the metric specification is based on. You must specify ``false`` for ``ReturnData`` for all the other metrics and expressions used in the metric specification.
+
+            If you are only retrieving metrics and not performing any math expressions, do not specify anything for ``ReturnData`` . This sets it to its default ( ``true`` ).
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-targettrackingmetricdataquery.html#cfn-autoscaling-scalingpolicy-targettrackingmetricdataquery-returndata
+            '''
+            result = self._values.get("return_data")
+            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
+
+        def __eq__(self, rhs: typing.Any) -> builtins.bool:
+            return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+        def __ne__(self, rhs: typing.Any) -> builtins.bool:
+            return not (rhs == self)
+
+        def __repr__(self) -> str:
+            return "TargetTrackingMetricDataQueryProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_autoscaling.CfnScalingPolicy.TargetTrackingMetricStatProperty",
+        jsii_struct_bases=[],
+        name_mapping={"metric": "metric", "stat": "stat", "unit": "unit"},
+    )
+    class TargetTrackingMetricStatProperty:
+        def __init__(
+            self,
+            *,
+            metric: typing.Union[_IResolvable_da3f097b, typing.Union["CfnScalingPolicy.MetricProperty", typing.Dict[builtins.str, typing.Any]]],
+            stat: builtins.str,
+            unit: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''``TargetTrackingMetricStat`` is a property of the `AWS::AutoScaling::ScalingPolicy TargetTrackingMetricDataQuery <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-targettrackingmetricdataquery.html>`_ property type.
+
+            This structure defines the CloudWatch metric to return, along with the statistic and unit.
+
+            For more information about the CloudWatch terminology below, see `Amazon CloudWatch concepts <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html>`_ in the *Amazon CloudWatch User Guide* .
+
+            :param metric: The metric to use.
+            :param stat: The statistic to return. It can include any CloudWatch statistic or extended statistic. For a list of valid values, see the table in `Statistics <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#Statistic>`_ in the *Amazon CloudWatch User Guide* . The most commonly used metric for scaling is ``Average`` .
+            :param unit: The unit to use for the returned data points. For a complete list of the units that CloudWatch supports, see the `MetricDatum <https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html>`_ data type in the *Amazon CloudWatch API Reference* .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-targettrackingmetricstat.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_autoscaling as autoscaling
+                
+                target_tracking_metric_stat_property = autoscaling.CfnScalingPolicy.TargetTrackingMetricStatProperty(
+                    metric=autoscaling.CfnScalingPolicy.MetricProperty(
+                        metric_name="metricName",
+                        namespace="namespace",
+                
+                        # the properties below are optional
+                        dimensions=[autoscaling.CfnScalingPolicy.MetricDimensionProperty(
+                            name="name",
+                            value="value"
+                        )]
+                    ),
+                    stat="stat",
+                
+                    # the properties below are optional
+                    unit="unit"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__75bb120fe0d7723abf802e828deb5b42b75d441e35d1a2974ff03b0a094adfb2)
+                check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
+                check_type(argname="argument stat", value=stat, expected_type=type_hints["stat"])
+                check_type(argname="argument unit", value=unit, expected_type=type_hints["unit"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "metric": metric,
+                "stat": stat,
+            }
+            if unit is not None:
+                self._values["unit"] = unit
+
+        @builtins.property
+        def metric(
+            self,
+        ) -> typing.Union[_IResolvable_da3f097b, "CfnScalingPolicy.MetricProperty"]:
+            '''The metric to use.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-targettrackingmetricstat.html#cfn-autoscaling-scalingpolicy-targettrackingmetricstat-metric
+            '''
+            result = self._values.get("metric")
+            assert result is not None, "Required property 'metric' is missing"
+            return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnScalingPolicy.MetricProperty"], result)
+
+        @builtins.property
+        def stat(self) -> builtins.str:
+            '''The statistic to return.
+
+            It can include any CloudWatch statistic or extended statistic. For a list of valid values, see the table in `Statistics <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#Statistic>`_ in the *Amazon CloudWatch User Guide* .
+
+            The most commonly used metric for scaling is ``Average`` .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-targettrackingmetricstat.html#cfn-autoscaling-scalingpolicy-targettrackingmetricstat-stat
+            '''
+            result = self._values.get("stat")
+            assert result is not None, "Required property 'stat' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def unit(self) -> typing.Optional[builtins.str]:
+            '''The unit to use for the returned data points.
+
+            For a complete list of the units that CloudWatch supports, see the `MetricDatum <https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html>`_ data type in the *Amazon CloudWatch API Reference* .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-autoscaling-scalingpolicy-targettrackingmetricstat.html#cfn-autoscaling-scalingpolicy-targettrackingmetricstat-unit
+            '''
+            result = self._values.get("unit")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        def __eq__(self, rhs: typing.Any) -> builtins.bool:
+            return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+        def __ne__(self, rhs: typing.Any) -> builtins.bool:
+            return not (rhs == self)
+
+        def __repr__(self) -> str:
+            return "TargetTrackingMetricStatProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
 
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_autoscaling.CfnScalingPolicyProps",
@@ -10861,15 +11219,37 @@ class CfnScalingPolicyProps:
             
                     # the properties below are optional
                     customized_metric_specification=autoscaling.CfnScalingPolicy.CustomizedMetricSpecificationProperty(
-                        metric_name="metricName",
-                        namespace="namespace",
-                        statistic="statistic",
-            
-                        # the properties below are optional
                         dimensions=[autoscaling.CfnScalingPolicy.MetricDimensionProperty(
                             name="name",
                             value="value"
                         )],
+                        metric_name="metricName",
+                        metrics=[autoscaling.CfnScalingPolicy.TargetTrackingMetricDataQueryProperty(
+                            id="id",
+            
+                            # the properties below are optional
+                            expression="expression",
+                            label="label",
+                            metric_stat=autoscaling.CfnScalingPolicy.TargetTrackingMetricStatProperty(
+                                metric=autoscaling.CfnScalingPolicy.MetricProperty(
+                                    metric_name="metricName",
+                                    namespace="namespace",
+            
+                                    # the properties below are optional
+                                    dimensions=[autoscaling.CfnScalingPolicy.MetricDimensionProperty(
+                                        name="name",
+                                        value="value"
+                                    )]
+                                ),
+                                stat="stat",
+            
+                                # the properties below are optional
+                                unit="unit"
+                            ),
+                            return_data=False
+                        )],
+                        namespace="namespace",
+                        statistic="statistic",
                         unit="unit"
                     ),
                     disable_scale_in=False,
@@ -20617,10 +20997,11 @@ def _typecheckingstub__c7edad0553749ec58702ad72a2bc68104268b76221c11cb19d8dd477a
 
 def _typecheckingstub__8e7031340719d237d3182678de0dc2931e386340d37c2dd60e36be75ada41bb3(
     *,
-    metric_name: builtins.str,
-    namespace: builtins.str,
-    statistic: builtins.str,
     dimensions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnScalingPolicy.MetricDimensionProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    metric_name: typing.Optional[builtins.str] = None,
+    metrics: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnScalingPolicy.TargetTrackingMetricDataQueryProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    namespace: typing.Optional[builtins.str] = None,
+    statistic: typing.Optional[builtins.str] = None,
     unit: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
@@ -20759,6 +21140,26 @@ def _typecheckingstub__406f504322f9bf5761a5c07083390725c370252fcf12bd54230e1f028
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__db2b2d9653863b1d1b8f67347857edde6d9dc3f6f755a593d8da143f90fe6fe7(
+    *,
+    id: builtins.str,
+    expression: typing.Optional[builtins.str] = None,
+    label: typing.Optional[builtins.str] = None,
+    metric_stat: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnScalingPolicy.TargetTrackingMetricStatProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    return_data: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__75bb120fe0d7723abf802e828deb5b42b75d441e35d1a2974ff03b0a094adfb2(
+    *,
+    metric: typing.Union[_IResolvable_da3f097b, typing.Union[CfnScalingPolicy.MetricProperty, typing.Dict[builtins.str, typing.Any]]],
+    stat: builtins.str,
+    unit: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__fa1549144f025fb75ca19967d6520b5eaada79209726c0ec131f1146e087fc7d(
     *,
     auto_scaling_group_name: builtins.str,