aws-cdk-lib 2.195.0__py3-none-any.whl → 2.224.0__py3-none-any.whl

aws_cdk/aws_aps/__init__.py

@@ -68,9 +68,1104 @@ from .. import (
     TagManager as _TagManager_0a598cb3,
     TreeInspector as _TreeInspector_488e0dd5,
 )
+from ..interfaces.aws_aps import (
+    AnomalyDetectorReference as _AnomalyDetectorReference_1ffc0c63,
+    IAnomalyDetectorRef as _IAnomalyDetectorRef_fef2b996,
+    IResourcePolicyRef as _IResourcePolicyRef_1aa7c1a2,
+    IRuleGroupsNamespaceRef as _IRuleGroupsNamespaceRef_7b589be9,
+    IScraperRef as _IScraperRef_2b17ef67,
+    IWorkspaceRef as _IWorkspaceRef_d8b2b588,
+    ResourcePolicyReference as _ResourcePolicyReference_162e786c,
+    RuleGroupsNamespaceReference as _RuleGroupsNamespaceReference_9d4673a3,
+    ScraperReference as _ScraperReference_c6b43df1,
+    WorkspaceReference as _WorkspaceReference_4f6a6126,
+)
+
+
+@jsii.implements(_IInspectable_c2943556, _IAnomalyDetectorRef_fef2b996, _ITaggableV2_4e6798f8)
+class CfnAnomalyDetector(
+    _CfnResource_9df397a6,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_aps.CfnAnomalyDetector",
+):
+    '''Anomaly detection uses the Random Cut Forest algorithm for time-series analysis.
+
+    The anomaly detector analyzes Amazon Managed Service for Prometheus metrics to identify unusual patterns and behaviors.
+
+    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-anomalydetector.html
+    :cloudformationResource: AWS::APS::AnomalyDetector
+    :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_aps as aps
+        
+        cfn_anomaly_detector = aps.CfnAnomalyDetector(self, "MyCfnAnomalyDetector",
+            alias="alias",
+            configuration=aps.CfnAnomalyDetector.AnomalyDetectorConfigurationProperty(
+                random_cut_forest=aps.CfnAnomalyDetector.RandomCutForestConfigurationProperty(
+                    query="query",
+        
+                    # the properties below are optional
+                    ignore_near_expected_from_above=aps.CfnAnomalyDetector.IgnoreNearExpectedProperty(
+                        amount=123,
+                        ratio=123
+                    ),
+                    ignore_near_expected_from_below=aps.CfnAnomalyDetector.IgnoreNearExpectedProperty(
+                        amount=123,
+                        ratio=123
+                    ),
+                    sample_size=123,
+                    shingle_size=123
+                )
+            ),
+            workspace="workspace",
+        
+            # the properties below are optional
+            evaluation_interval_in_seconds=123,
+            labels=[aps.CfnAnomalyDetector.LabelProperty(
+                key="key",
+                value="value"
+            )],
+            missing_data_action=aps.CfnAnomalyDetector.MissingDataActionProperty(
+                mark_as_anomaly=False,
+                skip=False
+            ),
+            tags=[CfnTag(
+                key="key",
+                value="value"
+            )]
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        alias: builtins.str,
+        configuration: typing.Union[_IResolvable_da3f097b, typing.Union["CfnAnomalyDetector.AnomalyDetectorConfigurationProperty", typing.Dict[builtins.str, typing.Any]]],
+        workspace: builtins.str,
+        evaluation_interval_in_seconds: typing.Optional[jsii.Number] = None,
+        labels: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnAnomalyDetector.LabelProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
+        missing_data_action: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnAnomalyDetector.MissingDataActionProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
+    ) -> None:
+        '''Create a new ``AWS::APS::AnomalyDetector``.
+
+        :param scope: Scope in which this resource is defined.
+        :param id: Construct identifier for this resource (unique in its scope).
+        :param alias: The user-friendly name of the anomaly detector.
+        :param configuration: The algorithm configuration of the anomaly detector.
+        :param workspace: An Amazon Managed Service for Prometheus workspace is a logical and isolated Prometheus server dedicated to ingesting, storing, and querying your Prometheus-compatible metrics.
+        :param evaluation_interval_in_seconds: The frequency, in seconds, at which the anomaly detector evaluates metrics. Default: - 60
+        :param labels: The Amazon Managed Service for Prometheus metric labels associated with the anomaly detector.
+        :param missing_data_action: The action taken when data is missing during evaluation.
+        :param tags: The tags applied to the anomaly detector.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__58b3184629f18780da9f7c9eb2f8acdbdbb5190c9fc3ae41fdbbe34341ba0f26)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = CfnAnomalyDetectorProps(
+            alias=alias,
+            configuration=configuration,
+            workspace=workspace,
+            evaluation_interval_in_seconds=evaluation_interval_in_seconds,
+            labels=labels,
+            missing_data_action=missing_data_action,
+            tags=tags,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @jsii.member(jsii_name="inspect")
+    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
+        '''Examines the CloudFormation resource and discloses attributes.
+
+        :param inspector: tree inspector to collect and process attributes.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__36a9fa3c67c466703717001e2774dacca3fa612b6ec02f8b6361ad6736da0ec7)
+            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
+        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))
+
+    @jsii.member(jsii_name="renderProperties")
+    def _render_properties(
+        self,
+        props: typing.Mapping[builtins.str, typing.Any],
+    ) -> typing.Mapping[builtins.str, typing.Any]:
+        '''
+        :param props: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__1edc3473fdf33536207faf87047c2bef23ac4e4aecad53d1e0338308f0e5ab91)
+            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
+        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
+
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
+    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
+        '''The CloudFormation resource type name for this resource class.'''
+        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))
+
+    @builtins.property
+    @jsii.member(jsii_name="anomalyDetectorRef")
+    def anomaly_detector_ref(self) -> _AnomalyDetectorReference_1ffc0c63:
+        '''A reference to a AnomalyDetector resource.'''
+        return typing.cast(_AnomalyDetectorReference_1ffc0c63, jsii.get(self, "anomalyDetectorRef"))
+
+    @builtins.property
+    @jsii.member(jsii_name="attrArn")
+    def attr_arn(self) -> builtins.str:
+        '''The Amazon Resource Name (ARN) of the anomaly detector.
+
+        :cloudformationAttribute: Arn
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "attrArn"))
+
+    @builtins.property
+    @jsii.member(jsii_name="cdkTagManager")
+    def cdk_tag_manager(self) -> _TagManager_0a598cb3:
+        '''Tag Manager which manages the tags for this resource.'''
+        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "cdkTagManager"))
+
+    @builtins.property
+    @jsii.member(jsii_name="cfnProperties")
+    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
+        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))
+
+    @builtins.property
+    @jsii.member(jsii_name="alias")
+    def alias(self) -> builtins.str:
+        '''The user-friendly name of the anomaly detector.'''
+        return typing.cast(builtins.str, jsii.get(self, "alias"))
+
+    @alias.setter
+    def alias(self, value: builtins.str) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__fe3aa1b72ccc7677675b2ae76ae8e5e1dfd2146dae8eba7520a981184cdf780d)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "alias", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="configuration")
+    def configuration(
+        self,
+    ) -> typing.Union[_IResolvable_da3f097b, "CfnAnomalyDetector.AnomalyDetectorConfigurationProperty"]:
+        '''The algorithm configuration of the anomaly detector.'''
+        return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnAnomalyDetector.AnomalyDetectorConfigurationProperty"], jsii.get(self, "configuration"))
+
+    @configuration.setter
+    def configuration(
+        self,
+        value: typing.Union[_IResolvable_da3f097b, "CfnAnomalyDetector.AnomalyDetectorConfigurationProperty"],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__1394fe6b497d7add7f3c437f746b83234bfd1714418b007d2ca77fcaf2e486fa)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "configuration", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="workspace")
+    def workspace(self) -> builtins.str:
+        '''An Amazon Managed Service for Prometheus workspace is a logical and isolated Prometheus server dedicated to ingesting, storing, and querying your Prometheus-compatible metrics.'''
+        return typing.cast(builtins.str, jsii.get(self, "workspace"))
+
+    @workspace.setter
+    def workspace(self, value: builtins.str) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__51d01d3c64410491a2005087b379e01fe1749ffd4be8e8dae194b7cc8e5e19b8)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "workspace", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="evaluationIntervalInSeconds")
+    def evaluation_interval_in_seconds(self) -> typing.Optional[jsii.Number]:
+        '''The frequency, in seconds, at which the anomaly detector evaluates metrics.'''
+        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "evaluationIntervalInSeconds"))
+
+    @evaluation_interval_in_seconds.setter
+    def evaluation_interval_in_seconds(
+        self,
+        value: typing.Optional[jsii.Number],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__ce3cb5189478c72429dee4d6fa1ed9635e537559491f15b775c279a89020cb75)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "evaluationIntervalInSeconds", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="labels")
+    def labels(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnAnomalyDetector.LabelProperty"]]]]:
+        '''The Amazon Managed Service for Prometheus metric labels associated with the anomaly detector.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnAnomalyDetector.LabelProperty"]]]], jsii.get(self, "labels"))
+
+    @labels.setter
+    def labels(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnAnomalyDetector.LabelProperty"]]]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__0d15555eb30ee6b4decc1dba71c708714ce1a7f00e658c2ce9c617f35dbea119)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "labels", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="missingDataAction")
+    def missing_data_action(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnAnomalyDetector.MissingDataActionProperty"]]:
+        '''The action taken when data is missing during evaluation.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnAnomalyDetector.MissingDataActionProperty"]], jsii.get(self, "missingDataAction"))
+
+    @missing_data_action.setter
+    def missing_data_action(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnAnomalyDetector.MissingDataActionProperty"]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__e639ced06e0101ba2e1108f2a5748e988f60e8c6ecadbb32ca0f2dc6162a53e8)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "missingDataAction", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="tags")
+    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
+        '''The tags applied to the anomaly detector.'''
+        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tags"))
+
+    @tags.setter
+    def tags(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__dc8b42c0f027d8c1c104a6037d9c3752efbfb2ae169c30d63f35dee5bad63b3f)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "tags", value) # pyright: ignore[reportArgumentType]
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_aps.CfnAnomalyDetector.AnomalyDetectorConfigurationProperty",
+        jsii_struct_bases=[],
+        name_mapping={"random_cut_forest": "randomCutForest"},
+    )
+    class AnomalyDetectorConfigurationProperty:
+        def __init__(
+            self,
+            *,
+            random_cut_forest: typing.Union[_IResolvable_da3f097b, typing.Union["CfnAnomalyDetector.RandomCutForestConfigurationProperty", typing.Dict[builtins.str, typing.Any]]],
+        ) -> None:
+            '''The configuration for the anomaly detection algorithm.
+
+            :param random_cut_forest: The Random Cut Forest algorithm configuration for anomaly detection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-anomalydetectorconfiguration.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_aps as aps
+                
+                anomaly_detector_configuration_property = aps.CfnAnomalyDetector.AnomalyDetectorConfigurationProperty(
+                    random_cut_forest=aps.CfnAnomalyDetector.RandomCutForestConfigurationProperty(
+                        query="query",
+                
+                        # the properties below are optional
+                        ignore_near_expected_from_above=aps.CfnAnomalyDetector.IgnoreNearExpectedProperty(
+                            amount=123,
+                            ratio=123
+                        ),
+                        ignore_near_expected_from_below=aps.CfnAnomalyDetector.IgnoreNearExpectedProperty(
+                            amount=123,
+                            ratio=123
+                        ),
+                        sample_size=123,
+                        shingle_size=123
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__aca672630a5e19c23bb68b82c63c873a7687610464d166cef0da5d6cde142082)
+                check_type(argname="argument random_cut_forest", value=random_cut_forest, expected_type=type_hints["random_cut_forest"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "random_cut_forest": random_cut_forest,
+            }
+
+        @builtins.property
+        def random_cut_forest(
+            self,
+        ) -> typing.Union[_IResolvable_da3f097b, "CfnAnomalyDetector.RandomCutForestConfigurationProperty"]:
+            '''The Random Cut Forest algorithm configuration for anomaly detection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-anomalydetectorconfiguration.html#cfn-aps-anomalydetector-anomalydetectorconfiguration-randomcutforest
+            '''
+            result = self._values.get("random_cut_forest")
+            assert result is not None, "Required property 'random_cut_forest' is missing"
+            return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnAnomalyDetector.RandomCutForestConfigurationProperty"], 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 "AnomalyDetectorConfigurationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_aps.CfnAnomalyDetector.IgnoreNearExpectedProperty",
+        jsii_struct_bases=[],
+        name_mapping={"amount": "amount", "ratio": "ratio"},
+    )
+    class IgnoreNearExpectedProperty:
+        def __init__(
+            self,
+            *,
+            amount: typing.Optional[jsii.Number] = None,
+            ratio: typing.Optional[jsii.Number] = None,
+        ) -> None:
+            '''Configuration for threshold settings that determine when values near expected values should be ignored during anomaly detection.
+
+            :param amount: The absolute amount by which values can differ from expected values before being considered anomalous.
+            :param ratio: The ratio by which values can differ from expected values before being considered anomalous.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-ignorenearexpected.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_aps as aps
+                
+                ignore_near_expected_property = aps.CfnAnomalyDetector.IgnoreNearExpectedProperty(
+                    amount=123,
+                    ratio=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__e3e1cf276ea5a24efc7ebe9d526fad4e86dd66a3f55ea5a0dcb3a617b8d62dff)
+                check_type(argname="argument amount", value=amount, expected_type=type_hints["amount"])
+                check_type(argname="argument ratio", value=ratio, expected_type=type_hints["ratio"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if amount is not None:
+                self._values["amount"] = amount
+            if ratio is not None:
+                self._values["ratio"] = ratio
+
+        @builtins.property
+        def amount(self) -> typing.Optional[jsii.Number]:
+            '''The absolute amount by which values can differ from expected values before being considered anomalous.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-ignorenearexpected.html#cfn-aps-anomalydetector-ignorenearexpected-amount
+            '''
+            result = self._values.get("amount")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def ratio(self) -> typing.Optional[jsii.Number]:
+            '''The ratio by which values can differ from expected values before being considered anomalous.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-ignorenearexpected.html#cfn-aps-anomalydetector-ignorenearexpected-ratio
+            '''
+            result = self._values.get("ratio")
+            return typing.cast(typing.Optional[jsii.Number], 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 "IgnoreNearExpectedProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_aps.CfnAnomalyDetector.LabelProperty",
+        jsii_struct_bases=[],
+        name_mapping={"key": "key", "value": "value"},
+    )
+    class LabelProperty:
+        def __init__(self, *, key: builtins.str, value: builtins.str) -> None:
+            '''The Amazon Managed Service for Prometheus metric labels associated with the anomaly detector.
+
+            :param key: The key of the label.
+            :param value: The value for this label.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-label.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_aps as aps
+                
+                label_property = aps.CfnAnomalyDetector.LabelProperty(
+                    key="key",
+                    value="value"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__3f784d604d60c49dd5fb567dcfedcd9d16e2ce47ba899589a373c9322818035a)
+                check_type(argname="argument key", value=key, expected_type=type_hints["key"])
+                check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "key": key,
+                "value": value,
+            }
+
+        @builtins.property
+        def key(self) -> builtins.str:
+            '''The key of the label.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-label.html#cfn-aps-anomalydetector-label-key
+            '''
+            result = self._values.get("key")
+            assert result is not None, "Required property 'key' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def value(self) -> builtins.str:
+            '''The value for this label.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-label.html#cfn-aps-anomalydetector-label-value
+            '''
+            result = self._values.get("value")
+            assert result is not None, "Required property 'value' is missing"
+            return typing.cast(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 "LabelProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_aps.CfnAnomalyDetector.MissingDataActionProperty",
+        jsii_struct_bases=[],
+        name_mapping={"mark_as_anomaly": "markAsAnomaly", "skip": "skip"},
+    )
+    class MissingDataActionProperty:
+        def __init__(
+            self,
+            *,
+            mark_as_anomaly: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+            skip: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+        ) -> None:
+            '''Specifies the action to take when data is missing during anomaly detection evaluation.
+
+            :param mark_as_anomaly: Marks missing data points as anomalies.
+            :param skip: Skips evaluation when data is missing.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-missingdataaction.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_aps as aps
+                
+                missing_data_action_property = aps.CfnAnomalyDetector.MissingDataActionProperty(
+                    mark_as_anomaly=False,
+                    skip=False
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__e5b8457b72ba87aa14000e26b68e021fa4b19e4e88f3a022910dcd18542039d0)
+                check_type(argname="argument mark_as_anomaly", value=mark_as_anomaly, expected_type=type_hints["mark_as_anomaly"])
+                check_type(argname="argument skip", value=skip, expected_type=type_hints["skip"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if mark_as_anomaly is not None:
+                self._values["mark_as_anomaly"] = mark_as_anomaly
+            if skip is not None:
+                self._values["skip"] = skip
+
+        @builtins.property
+        def mark_as_anomaly(
+            self,
+        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+            '''Marks missing data points as anomalies.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-missingdataaction.html#cfn-aps-anomalydetector-missingdataaction-markasanomaly
+            '''
+            result = self._values.get("mark_as_anomaly")
+            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
+
+        @builtins.property
+        def skip(
+            self,
+        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+            '''Skips evaluation when data is missing.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-missingdataaction.html#cfn-aps-anomalydetector-missingdataaction-skip
+            '''
+            result = self._values.get("skip")
+            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 "MissingDataActionProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_aps.CfnAnomalyDetector.RandomCutForestConfigurationProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "query": "query",
+            "ignore_near_expected_from_above": "ignoreNearExpectedFromAbove",
+            "ignore_near_expected_from_below": "ignoreNearExpectedFromBelow",
+            "sample_size": "sampleSize",
+            "shingle_size": "shingleSize",
+        },
+    )
+    class RandomCutForestConfigurationProperty:
+        def __init__(
+            self,
+            *,
+            query: builtins.str,
+            ignore_near_expected_from_above: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnAnomalyDetector.IgnoreNearExpectedProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            ignore_near_expected_from_below: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnAnomalyDetector.IgnoreNearExpectedProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            sample_size: typing.Optional[jsii.Number] = None,
+            shingle_size: typing.Optional[jsii.Number] = None,
+        ) -> None:
+            '''Configuration for the Random Cut Forest algorithm used for anomaly detection in time-series data.
+
+            :param query: The Prometheus query used to retrieve the time-series data for anomaly detection. .. epigraph:: Random Cut Forest queries must be wrapped by a supported PromQL aggregation operator. For more information, see `Aggregation operators <https://docs.aws.amazon.com/https://prometheus.io/docs/prometheus/latest/querying/operators/#aggregation-operators>`_ on the *Prometheus docs* website. *Supported PromQL aggregation operators* : ``avg`` , ``count`` , ``group`` , ``max`` , ``min`` , ``quantile`` , ``stddev`` , ``stdvar`` , and ``sum`` .
+            :param ignore_near_expected_from_above: Configuration for ignoring values that are near expected values from above during anomaly detection.
+            :param ignore_near_expected_from_below: Configuration for ignoring values that are near expected values from below during anomaly detection.
+            :param sample_size: The number of data points sampled from the input stream for the Random Cut Forest algorithm. The default number is 256 consecutive data points. Default: - 256
+            :param shingle_size: The number of consecutive data points used to create a shingle for the Random Cut Forest algorithm. The default number is 8 consecutive data points. Default: - 8
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-randomcutforestconfiguration.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_aps as aps
+                
+                random_cut_forest_configuration_property = aps.CfnAnomalyDetector.RandomCutForestConfigurationProperty(
+                    query="query",
+                
+                    # the properties below are optional
+                    ignore_near_expected_from_above=aps.CfnAnomalyDetector.IgnoreNearExpectedProperty(
+                        amount=123,
+                        ratio=123
+                    ),
+                    ignore_near_expected_from_below=aps.CfnAnomalyDetector.IgnoreNearExpectedProperty(
+                        amount=123,
+                        ratio=123
+                    ),
+                    sample_size=123,
+                    shingle_size=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__83993f42a131a948093792cb8cd7b4f710c6b4dffce6b17f386497f1cbe514ea)
+                check_type(argname="argument query", value=query, expected_type=type_hints["query"])
+                check_type(argname="argument ignore_near_expected_from_above", value=ignore_near_expected_from_above, expected_type=type_hints["ignore_near_expected_from_above"])
+                check_type(argname="argument ignore_near_expected_from_below", value=ignore_near_expected_from_below, expected_type=type_hints["ignore_near_expected_from_below"])
+                check_type(argname="argument sample_size", value=sample_size, expected_type=type_hints["sample_size"])
+                check_type(argname="argument shingle_size", value=shingle_size, expected_type=type_hints["shingle_size"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "query": query,
+            }
+            if ignore_near_expected_from_above is not None:
+                self._values["ignore_near_expected_from_above"] = ignore_near_expected_from_above
+            if ignore_near_expected_from_below is not None:
+                self._values["ignore_near_expected_from_below"] = ignore_near_expected_from_below
+            if sample_size is not None:
+                self._values["sample_size"] = sample_size
+            if shingle_size is not None:
+                self._values["shingle_size"] = shingle_size
+
+        @builtins.property
+        def query(self) -> builtins.str:
+            '''The Prometheus query used to retrieve the time-series data for anomaly detection.
+
+            .. epigraph::
+
+               Random Cut Forest queries must be wrapped by a supported PromQL aggregation operator. For more information, see `Aggregation operators <https://docs.aws.amazon.com/https://prometheus.io/docs/prometheus/latest/querying/operators/#aggregation-operators>`_ on the *Prometheus docs* website.
+
+               *Supported PromQL aggregation operators* : ``avg`` , ``count`` , ``group`` , ``max`` , ``min`` , ``quantile`` , ``stddev`` , ``stdvar`` , and ``sum`` .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-randomcutforestconfiguration.html#cfn-aps-anomalydetector-randomcutforestconfiguration-query
+            '''
+            result = self._values.get("query")
+            assert result is not None, "Required property 'query' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def ignore_near_expected_from_above(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnAnomalyDetector.IgnoreNearExpectedProperty"]]:
+            '''Configuration for ignoring values that are near expected values from above during anomaly detection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-randomcutforestconfiguration.html#cfn-aps-anomalydetector-randomcutforestconfiguration-ignorenearexpectedfromabove
+            '''
+            result = self._values.get("ignore_near_expected_from_above")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnAnomalyDetector.IgnoreNearExpectedProperty"]], result)
+
+        @builtins.property
+        def ignore_near_expected_from_below(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnAnomalyDetector.IgnoreNearExpectedProperty"]]:
+            '''Configuration for ignoring values that are near expected values from below during anomaly detection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-randomcutforestconfiguration.html#cfn-aps-anomalydetector-randomcutforestconfiguration-ignorenearexpectedfrombelow
+            '''
+            result = self._values.get("ignore_near_expected_from_below")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnAnomalyDetector.IgnoreNearExpectedProperty"]], result)
+
+        @builtins.property
+        def sample_size(self) -> typing.Optional[jsii.Number]:
+            '''The number of data points sampled from the input stream for the Random Cut Forest algorithm.
+
+            The default number is 256 consecutive data points.
+
+            :default: - 256
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-randomcutforestconfiguration.html#cfn-aps-anomalydetector-randomcutforestconfiguration-samplesize
+            '''
+            result = self._values.get("sample_size")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def shingle_size(self) -> typing.Optional[jsii.Number]:
+            '''The number of consecutive data points used to create a shingle for the Random Cut Forest algorithm.
+
+            The default number is 8 consecutive data points.
+
+            :default: - 8
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-anomalydetector-randomcutforestconfiguration.html#cfn-aps-anomalydetector-randomcutforestconfiguration-shinglesize
+            '''
+            result = self._values.get("shingle_size")
+            return typing.cast(typing.Optional[jsii.Number], 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 "RandomCutForestConfigurationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_aps.CfnAnomalyDetectorProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "alias": "alias",
+        "configuration": "configuration",
+        "workspace": "workspace",
+        "evaluation_interval_in_seconds": "evaluationIntervalInSeconds",
+        "labels": "labels",
+        "missing_data_action": "missingDataAction",
+        "tags": "tags",
+    },
+)
+class CfnAnomalyDetectorProps:
+    def __init__(
+        self,
+        *,
+        alias: builtins.str,
+        configuration: typing.Union[_IResolvable_da3f097b, typing.Union[CfnAnomalyDetector.AnomalyDetectorConfigurationProperty, typing.Dict[builtins.str, typing.Any]]],
+        workspace: builtins.str,
+        evaluation_interval_in_seconds: typing.Optional[jsii.Number] = None,
+        labels: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnAnomalyDetector.LabelProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+        missing_data_action: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnAnomalyDetector.MissingDataActionProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
+    ) -> None:
+        '''Properties for defining a ``CfnAnomalyDetector``.
+
+        :param alias: The user-friendly name of the anomaly detector.
+        :param configuration: The algorithm configuration of the anomaly detector.
+        :param workspace: An Amazon Managed Service for Prometheus workspace is a logical and isolated Prometheus server dedicated to ingesting, storing, and querying your Prometheus-compatible metrics.
+        :param evaluation_interval_in_seconds: The frequency, in seconds, at which the anomaly detector evaluates metrics. Default: - 60
+        :param labels: The Amazon Managed Service for Prometheus metric labels associated with the anomaly detector.
+        :param missing_data_action: The action taken when data is missing during evaluation.
+        :param tags: The tags applied to the anomaly detector.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-anomalydetector.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_aps as aps
+            
+            cfn_anomaly_detector_props = aps.CfnAnomalyDetectorProps(
+                alias="alias",
+                configuration=aps.CfnAnomalyDetector.AnomalyDetectorConfigurationProperty(
+                    random_cut_forest=aps.CfnAnomalyDetector.RandomCutForestConfigurationProperty(
+                        query="query",
+            
+                        # the properties below are optional
+                        ignore_near_expected_from_above=aps.CfnAnomalyDetector.IgnoreNearExpectedProperty(
+                            amount=123,
+                            ratio=123
+                        ),
+                        ignore_near_expected_from_below=aps.CfnAnomalyDetector.IgnoreNearExpectedProperty(
+                            amount=123,
+                            ratio=123
+                        ),
+                        sample_size=123,
+                        shingle_size=123
+                    )
+                ),
+                workspace="workspace",
+            
+                # the properties below are optional
+                evaluation_interval_in_seconds=123,
+                labels=[aps.CfnAnomalyDetector.LabelProperty(
+                    key="key",
+                    value="value"
+                )],
+                missing_data_action=aps.CfnAnomalyDetector.MissingDataActionProperty(
+                    mark_as_anomaly=False,
+                    skip=False
+                ),
+                tags=[CfnTag(
+                    key="key",
+                    value="value"
+                )]
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__be017a909bcb870b1880c9bb2c099abc51df504e0f9199ca315deb7fa50b9d6b)
+            check_type(argname="argument alias", value=alias, expected_type=type_hints["alias"])
+            check_type(argname="argument configuration", value=configuration, expected_type=type_hints["configuration"])
+            check_type(argname="argument workspace", value=workspace, expected_type=type_hints["workspace"])
+            check_type(argname="argument evaluation_interval_in_seconds", value=evaluation_interval_in_seconds, expected_type=type_hints["evaluation_interval_in_seconds"])
+            check_type(argname="argument labels", value=labels, expected_type=type_hints["labels"])
+            check_type(argname="argument missing_data_action", value=missing_data_action, expected_type=type_hints["missing_data_action"])
+            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "alias": alias,
+            "configuration": configuration,
+            "workspace": workspace,
+        }
+        if evaluation_interval_in_seconds is not None:
+            self._values["evaluation_interval_in_seconds"] = evaluation_interval_in_seconds
+        if labels is not None:
+            self._values["labels"] = labels
+        if missing_data_action is not None:
+            self._values["missing_data_action"] = missing_data_action
+        if tags is not None:
+            self._values["tags"] = tags
+
+    @builtins.property
+    def alias(self) -> builtins.str:
+        '''The user-friendly name of the anomaly detector.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-anomalydetector.html#cfn-aps-anomalydetector-alias
+        '''
+        result = self._values.get("alias")
+        assert result is not None, "Required property 'alias' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def configuration(
+        self,
+    ) -> typing.Union[_IResolvable_da3f097b, CfnAnomalyDetector.AnomalyDetectorConfigurationProperty]:
+        '''The algorithm configuration of the anomaly detector.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-anomalydetector.html#cfn-aps-anomalydetector-configuration
+        '''
+        result = self._values.get("configuration")
+        assert result is not None, "Required property 'configuration' is missing"
+        return typing.cast(typing.Union[_IResolvable_da3f097b, CfnAnomalyDetector.AnomalyDetectorConfigurationProperty], result)
+
+    @builtins.property
+    def workspace(self) -> builtins.str:
+        '''An Amazon Managed Service for Prometheus workspace is a logical and isolated Prometheus server dedicated to ingesting, storing, and querying your Prometheus-compatible metrics.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-anomalydetector.html#cfn-aps-anomalydetector-workspace
+        '''
+        result = self._values.get("workspace")
+        assert result is not None, "Required property 'workspace' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def evaluation_interval_in_seconds(self) -> typing.Optional[jsii.Number]:
+        '''The frequency, in seconds, at which the anomaly detector evaluates metrics.
+
+        :default: - 60
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-anomalydetector.html#cfn-aps-anomalydetector-evaluationintervalinseconds
+        '''
+        result = self._values.get("evaluation_interval_in_seconds")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def labels(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnAnomalyDetector.LabelProperty]]]]:
+        '''The Amazon Managed Service for Prometheus metric labels associated with the anomaly detector.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-anomalydetector.html#cfn-aps-anomalydetector-labels
+        '''
+        result = self._values.get("labels")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnAnomalyDetector.LabelProperty]]]], result)
+
+    @builtins.property
+    def missing_data_action(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnAnomalyDetector.MissingDataActionProperty]]:
+        '''The action taken when data is missing during evaluation.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-anomalydetector.html#cfn-aps-anomalydetector-missingdataaction
+        '''
+        result = self._values.get("missing_data_action")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnAnomalyDetector.MissingDataActionProperty]], result)
+
+    @builtins.property
+    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
+        '''The tags applied to the anomaly detector.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-anomalydetector.html#cfn-aps-anomalydetector-tags
+        '''
+        result = self._values.get("tags")
+        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], 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 "CfnAnomalyDetectorProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.implements(_IInspectable_c2943556, _IResourcePolicyRef_1aa7c1a2)
+class CfnResourcePolicy(
+    _CfnResource_9df397a6,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_aps.CfnResourcePolicy",
+):
+    '''Use resource-based policies to grant permissions to other AWS accounts or services to access your workspace.
+
+    Only Prometheus-compatible APIs can be used for workspace sharing. You can add non-Prometheus-compatible APIs to the policy, but they will be ignored. For more information, see `Prometheus-compatible APIs <https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-APIReference-Prometheus-Compatible-Apis.html>`_ in the *Amazon Managed Service for Prometheus User Guide* .
+
+    If your workspace uses customer-managed AWS KMS keys for encryption, you must grant the principals in your resource-based policy access to those AWS KMS keys. You can do this by creating AWS KMS grants. For more information, see `CreateGrant <https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html>`_ in the *AWS KMS API Reference* and `Encryption at rest <https://docs.aws.amazon.com/prometheus/latest/userguide/encryption-at-rest-Amazon-Service-Prometheus.html>`_ in the *Amazon Managed Service for Prometheus User Guide* .
+
+    For more information about working with IAM , see `Using Amazon Managed Service for Prometheus with IAM <https://docs.aws.amazon.com/prometheus/latest/userguide/security_iam_service-with-iam.html>`_ in the *Amazon Managed Service for Prometheus User Guide* .
+
+    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-resourcepolicy.html
+    :cloudformationResource: AWS::APS::ResourcePolicy
+    :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_aps as aps
+        
+        cfn_resource_policy = aps.CfnResourcePolicy(self, "MyCfnResourcePolicy",
+            policy_document="policyDocument",
+            workspace_arn="workspaceArn"
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        policy_document: builtins.str,
+        workspace_arn: builtins.str,
+    ) -> None:
+        '''Create a new ``AWS::APS::ResourcePolicy``.
+
+        :param scope: Scope in which this resource is defined.
+        :param id: Construct identifier for this resource (unique in its scope).
+        :param policy_document: The JSON to use as the Resource-based Policy.
+        :param workspace_arn: An ARN identifying a Workspace.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__54f89d9ee1d6d400f40f83801fe40dee056ce969e9e0501ca1390285aab7cb82)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = CfnResourcePolicyProps(
+            policy_document=policy_document, workspace_arn=workspace_arn
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @jsii.member(jsii_name="inspect")
+    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
+        '''Examines the CloudFormation resource and discloses attributes.
+
+        :param inspector: tree inspector to collect and process attributes.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__7fd684bb5425ae9b9586530c2118e55043226673b8740171d3f7c2b1fbd03b3d)
+            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
+        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))
+
+    @jsii.member(jsii_name="renderProperties")
+    def _render_properties(
+        self,
+        props: typing.Mapping[builtins.str, typing.Any],
+    ) -> typing.Mapping[builtins.str, typing.Any]:
+        '''
+        :param props: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__96c6a584b0420e6cc37e76ad4b000bc6d8f4137f577bf7075b4ec87bab8717d9)
+            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
+        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
+
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
+    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
+        '''The CloudFormation resource type name for this resource class.'''
+        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))
+
+    @builtins.property
+    @jsii.member(jsii_name="cfnProperties")
+    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
+        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))
+
+    @builtins.property
+    @jsii.member(jsii_name="resourcePolicyRef")
+    def resource_policy_ref(self) -> _ResourcePolicyReference_162e786c:
+        '''A reference to a ResourcePolicy resource.'''
+        return typing.cast(_ResourcePolicyReference_162e786c, jsii.get(self, "resourcePolicyRef"))
+
+    @builtins.property
+    @jsii.member(jsii_name="policyDocument")
+    def policy_document(self) -> builtins.str:
+        '''The JSON to use as the Resource-based Policy.'''
+        return typing.cast(builtins.str, jsii.get(self, "policyDocument"))
+
+    @policy_document.setter
+    def policy_document(self, value: builtins.str) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__d726921aa53fc43f461134d2df5d60edb5d56b4fa67ef6e4e82d305af7b7eba5)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "policyDocument", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="workspaceArn")
+    def workspace_arn(self) -> builtins.str:
+        '''An ARN identifying a Workspace.'''
+        return typing.cast(builtins.str, jsii.get(self, "workspaceArn"))
+
+    @workspace_arn.setter
+    def workspace_arn(self, value: builtins.str) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__2f020f5d54f91c35f0b4332b16391ef6561cfc07a46cc5fc1e48d4acdb82a4b8)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "workspaceArn", value) # pyright: ignore[reportArgumentType]
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_aps.CfnResourcePolicyProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "policy_document": "policyDocument",
+        "workspace_arn": "workspaceArn",
+    },
+)
+class CfnResourcePolicyProps:
+    def __init__(
+        self,
+        *,
+        policy_document: builtins.str,
+        workspace_arn: builtins.str,
+    ) -> None:
+        '''Properties for defining a ``CfnResourcePolicy``.
+
+        :param policy_document: The JSON to use as the Resource-based Policy.
+        :param workspace_arn: An ARN identifying a Workspace.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-resourcepolicy.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_aps as aps
+            
+            cfn_resource_policy_props = aps.CfnResourcePolicyProps(
+                policy_document="policyDocument",
+                workspace_arn="workspaceArn"
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__bb05747fc90b1776c66fd40ec5d261399f93ac6b367fc973d5df8b912bd30997)
+            check_type(argname="argument policy_document", value=policy_document, expected_type=type_hints["policy_document"])
+            check_type(argname="argument workspace_arn", value=workspace_arn, expected_type=type_hints["workspace_arn"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "policy_document": policy_document,
+            "workspace_arn": workspace_arn,
+        }
+
+    @builtins.property
+    def policy_document(self) -> builtins.str:
+        '''The JSON to use as the Resource-based Policy.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-resourcepolicy.html#cfn-aps-resourcepolicy-policydocument
+        '''
+        result = self._values.get("policy_document")
+        assert result is not None, "Required property 'policy_document' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def workspace_arn(self) -> builtins.str:
+        '''An ARN identifying a Workspace.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-resourcepolicy.html#cfn-aps-resourcepolicy-workspacearn
+        '''
+        result = self._values.get("workspace_arn")
+        assert result is not None, "Required property 'workspace_arn' is missing"
+        return typing.cast(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 "CfnResourcePolicyProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
 
 
-@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
+@jsii.implements(_IInspectable_c2943556, _IRuleGroupsNamespaceRef_7b589be9, _ITaggable_36806126)
 class CfnRuleGroupsNamespace(
     _CfnResource_9df397a6,
     metaclass=jsii.JSIIMeta,
@@ -113,7 +1208,8 @@ class CfnRuleGroupsNamespace(
         workspace: builtins.str,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
-        '''
+        '''Create a new ``AWS::APS::RuleGroupsNamespace``.
+
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
         :param data: The rules file used in the namespace. For more details about the rules file, see `Creating a rules file <https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-ruler-rulesfile.html>`_ in the *Amazon Managed Service for Prometheus User Guide* .
@@ -177,6 +1273,12 @@ class CfnRuleGroupsNamespace(
     def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
         return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))
 
+    @builtins.property
+    @jsii.member(jsii_name="ruleGroupsNamespaceRef")
+    def rule_groups_namespace_ref(self) -> _RuleGroupsNamespaceReference_9d4673a3:
+        '''A reference to a RuleGroupsNamespace resource.'''
+        return typing.cast(_RuleGroupsNamespaceReference_9d4673a3, jsii.get(self, "ruleGroupsNamespaceRef"))
+
     @builtins.property
     @jsii.member(jsii_name="tags")
     def tags(self) -> _TagManager_0a598cb3:
@@ -350,7 +1452,7 @@ class CfnRuleGroupsNamespaceProps:
         )
 
 
-@jsii.implements(_IInspectable_c2943556, _ITaggableV2_4e6798f8)
+@jsii.implements(_IInspectable_c2943556, _IScraperRef_2b17ef67, _ITaggableV2_4e6798f8)
 class CfnScraper(
     _CfnResource_9df397a6,
     metaclass=jsii.JSIIMeta,
@@ -402,6 +1504,23 @@ class CfnScraper(
                 source_role_arn="sourceRoleArn",
                 target_role_arn="targetRoleArn"
             ),
+            scraper_logging_configuration=aps.CfnScraper.ScraperLoggingConfigurationProperty(
+                logging_destination=aps.CfnScraper.ScraperLoggingDestinationProperty(
+                    cloud_watch_logs=aps.CfnScraper.CloudWatchLogDestinationProperty(
+                        log_group_arn="logGroupArn"
+                    )
+                ),
+                scraper_components=[aps.CfnScraper.ScraperComponentProperty(
+                    type="type",
+        
+                    # the properties below are optional
+                    config=aps.CfnScraper.ComponentConfigProperty(
+                        options={
+                            "options_key": "options"
+                        }
+                    )
+                )]
+            ),
             tags=[CfnTag(
                 key="key",
                 value="value"
@@ -419,16 +1538,19 @@ class CfnScraper(
         source: typing.Union[_IResolvable_da3f097b, typing.Union["CfnScraper.SourceProperty", typing.Dict[builtins.str, typing.Any]]],
         alias: typing.Optional[builtins.str] = None,
         role_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnScraper.RoleConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        scraper_logging_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnScraper.ScraperLoggingConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
-        '''
+        '''Create a new ``AWS::APS::Scraper``.
+
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
         :param destination: The Amazon Managed Service for Prometheus workspace the scraper sends metrics to.
         :param scrape_configuration: The configuration in use by the scraper.
         :param source: The Amazon EKS cluster from which the scraper collects metrics.
         :param alias: An optional user-assigned scraper alias.
-        :param role_configuration: Role configuration.
+        :param role_configuration: The role configuration in an Amazon Managed Service for Prometheus scraper.
+        :param scraper_logging_configuration: The definition of logging configuration in an Amazon Managed Service for Prometheus workspace.
         :param tags: (Optional) The list of tag keys and values associated with the scraper.
         '''
         if __debug__:
@@ -441,6 +1563,7 @@ class CfnScraper(
             source=source,
             alias=alias,
             role_configuration=role_configuration,
+            scraper_logging_configuration=scraper_logging_configuration,
             tags=tags,
         )
 
@@ -520,6 +1643,12 @@ class CfnScraper(
     def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
         return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))
 
+    @builtins.property
+    @jsii.member(jsii_name="scraperRef")
+    def scraper_ref(self) -> _ScraperReference_c6b43df1:
+        '''A reference to a Scraper resource.'''
+        return typing.cast(_ScraperReference_c6b43df1, jsii.get(self, "scraperRef"))
+
     @builtins.property
     @jsii.member(jsii_name="destination")
     def destination(
@@ -592,7 +1721,7 @@ class CfnScraper(
     def role_configuration(
         self,
     ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnScraper.RoleConfigurationProperty"]]:
-        '''Role configuration.'''
+        '''The role configuration in an Amazon Managed Service for Prometheus scraper.'''
         return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnScraper.RoleConfigurationProperty"]], jsii.get(self, "roleConfiguration"))
 
     @role_configuration.setter
@@ -605,6 +1734,24 @@ class CfnScraper(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "roleConfiguration", value) # pyright: ignore[reportArgumentType]
 
+    @builtins.property
+    @jsii.member(jsii_name="scraperLoggingConfiguration")
+    def scraper_logging_configuration(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnScraper.ScraperLoggingConfigurationProperty"]]:
+        '''The definition of logging configuration in an Amazon Managed Service for Prometheus workspace.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnScraper.ScraperLoggingConfigurationProperty"]], jsii.get(self, "scraperLoggingConfiguration"))
+
+    @scraper_logging_configuration.setter
+    def scraper_logging_configuration(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnScraper.ScraperLoggingConfigurationProperty"]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__98c937c38a5c278540b0a6d9654c4dc0d8dbc46a2f3145fd9275f2a8fd9ce000)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "scraperLoggingConfiguration", value) # pyright: ignore[reportArgumentType]
+
     @builtins.property
     @jsii.member(jsii_name="tags")
     def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
@@ -670,6 +1817,120 @@ class CfnScraper(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_aps.CfnScraper.CloudWatchLogDestinationProperty",
+        jsii_struct_bases=[],
+        name_mapping={"log_group_arn": "logGroupArn"},
+    )
+    class CloudWatchLogDestinationProperty:
+        def __init__(
+            self,
+            *,
+            log_group_arn: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''Represents a cloudwatch logs destination for scraper logging.
+
+            :param log_group_arn: ARN of the CloudWatch log group.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-scraper-cloudwatchlogdestination.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_aps as aps
+                
+                cloud_watch_log_destination_property = aps.CfnScraper.CloudWatchLogDestinationProperty(
+                    log_group_arn="logGroupArn"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__d4d1b8a234d9b0461189ac94d16b7043b8e40fc1a62680a811ba8396bc54a5d6)
+                check_type(argname="argument log_group_arn", value=log_group_arn, expected_type=type_hints["log_group_arn"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if log_group_arn is not None:
+                self._values["log_group_arn"] = log_group_arn
+
+        @builtins.property
+        def log_group_arn(self) -> typing.Optional[builtins.str]:
+            '''ARN of the CloudWatch log group.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-scraper-cloudwatchlogdestination.html#cfn-aps-scraper-cloudwatchlogdestination-loggrouparn
+            '''
+            result = self._values.get("log_group_arn")
+            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 "CloudWatchLogDestinationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_aps.CfnScraper.ComponentConfigProperty",
+        jsii_struct_bases=[],
+        name_mapping={"options": "options"},
+    )
+    class ComponentConfigProperty:
+        def __init__(
+            self,
+            *,
+            options: typing.Optional[typing.Union[typing.Mapping[builtins.str, builtins.str], _IResolvable_da3f097b]] = None,
+        ) -> None:
+            '''Configuration settings for a scraper component.
+
+            :param options: Configuration options for the scraper component.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-scraper-componentconfig.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_aps as aps
+                
+                component_config_property = aps.CfnScraper.ComponentConfigProperty(
+                    options={
+                        "options_key": "options"
+                    }
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__c81abd8a9526f73204a9bfa774d69e9b3ec81f7592dafabd756679cc66dcb1e1)
+                check_type(argname="argument options", value=options, expected_type=type_hints["options"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if options is not None:
+                self._values["options"] = options
+
+        @builtins.property
+        def options(
+            self,
+        ) -> typing.Optional[typing.Union[typing.Mapping[builtins.str, builtins.str], _IResolvable_da3f097b]]:
+            '''Configuration options for the scraper component.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-scraper-componentconfig.html#cfn-aps-scraper-componentconfig-options
+            '''
+            result = self._values.get("options")
+            return typing.cast(typing.Optional[typing.Union[typing.Mapping[builtins.str, builtins.str], _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 "ComponentConfigProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_aps.CfnScraper.DestinationProperty",
         jsii_struct_bases=[],
@@ -837,10 +2098,10 @@ class CfnScraper(
             source_role_arn: typing.Optional[builtins.str] = None,
             target_role_arn: typing.Optional[builtins.str] = None,
         ) -> None:
-            '''Role configuration.
+            '''The role configuration in an Amazon Managed Service for Prometheus scraper.
 
-            :param source_role_arn: IAM Role in source account.
-            :param target_role_arn: IAM Role in the target account.
+            :param source_role_arn: The ARN of the source role.
+            :param target_role_arn: The ARN of the target role.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-scraper-roleconfiguration.html
             :exampleMetadata: fixture=_generated
@@ -868,7 +2129,7 @@ class CfnScraper(
 
         @builtins.property
         def source_role_arn(self) -> typing.Optional[builtins.str]:
-            '''IAM Role in source account.
+            '''The ARN of the source role.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-scraper-roleconfiguration.html#cfn-aps-scraper-roleconfiguration-sourcerolearn
             '''
@@ -877,7 +2138,7 @@ class CfnScraper(
 
         @builtins.property
         def target_role_arn(self) -> typing.Optional[builtins.str]:
-            '''IAM Role in the target account.
+            '''The ARN of the target role.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-scraper-roleconfiguration.html#cfn-aps-scraper-roleconfiguration-targetrolearn
             '''
@@ -934,9 +2195,237 @@ class CfnScraper(
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-scraper-scrapeconfiguration.html#cfn-aps-scraper-scrapeconfiguration-configurationblob
             '''
-            result = self._values.get("configuration_blob")
-            assert result is not None, "Required property 'configuration_blob' is missing"
-            return typing.cast(builtins.str, result)
+            result = self._values.get("configuration_blob")
+            assert result is not None, "Required property 'configuration_blob' is missing"
+            return typing.cast(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 "ScrapeConfigurationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_aps.CfnScraper.ScraperComponentProperty",
+        jsii_struct_bases=[],
+        name_mapping={"type": "type", "config": "config"},
+    )
+    class ScraperComponentProperty:
+        def __init__(
+            self,
+            *,
+            type: builtins.str,
+            config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnScraper.ComponentConfigProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        ) -> None:
+            '''A component of a Amazon Managed Service for Prometheus scraper that can be configured for logging.
+
+            :param type: The type of the scraper component.
+            :param config: The configuration settings for the scraper component.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-scraper-scrapercomponent.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_aps as aps
+                
+                scraper_component_property = aps.CfnScraper.ScraperComponentProperty(
+                    type="type",
+                
+                    # the properties below are optional
+                    config=aps.CfnScraper.ComponentConfigProperty(
+                        options={
+                            "options_key": "options"
+                        }
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__be259f573540cfe3fb130cbc10c656811dffac0fb6663b27b9f4982549990b6a)
+                check_type(argname="argument type", value=type, expected_type=type_hints["type"])
+                check_type(argname="argument config", value=config, expected_type=type_hints["config"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "type": type,
+            }
+            if config is not None:
+                self._values["config"] = config
+
+        @builtins.property
+        def type(self) -> builtins.str:
+            '''The type of the scraper component.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-scraper-scrapercomponent.html#cfn-aps-scraper-scrapercomponent-type
+            '''
+            result = self._values.get("type")
+            assert result is not None, "Required property 'type' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def config(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnScraper.ComponentConfigProperty"]]:
+            '''The configuration settings for the scraper component.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-scraper-scrapercomponent.html#cfn-aps-scraper-scrapercomponent-config
+            '''
+            result = self._values.get("config")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnScraper.ComponentConfigProperty"]], 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 "ScraperComponentProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_aps.CfnScraper.ScraperLoggingConfigurationProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "logging_destination": "loggingDestination",
+            "scraper_components": "scraperComponents",
+        },
+    )
+    class ScraperLoggingConfigurationProperty:
+        def __init__(
+            self,
+            *,
+            logging_destination: typing.Union[_IResolvable_da3f097b, typing.Union["CfnScraper.ScraperLoggingDestinationProperty", typing.Dict[builtins.str, typing.Any]]],
+            scraper_components: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnScraper.ScraperComponentProperty", typing.Dict[builtins.str, typing.Any]]]]],
+        ) -> None:
+            '''Configuration for scraper logging.
+
+            :param logging_destination: Destination for scraper logging.
+            :param scraper_components: 
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-scraper-scraperloggingconfiguration.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_aps as aps
+                
+                scraper_logging_configuration_property = aps.CfnScraper.ScraperLoggingConfigurationProperty(
+                    logging_destination=aps.CfnScraper.ScraperLoggingDestinationProperty(
+                        cloud_watch_logs=aps.CfnScraper.CloudWatchLogDestinationProperty(
+                            log_group_arn="logGroupArn"
+                        )
+                    ),
+                    scraper_components=[aps.CfnScraper.ScraperComponentProperty(
+                        type="type",
+                
+                        # the properties below are optional
+                        config=aps.CfnScraper.ComponentConfigProperty(
+                            options={
+                                "options_key": "options"
+                            }
+                        )
+                    )]
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__ea5221003b2ff43404935c67045669a8a84790d807c849eadd6df28ea9b60feb)
+                check_type(argname="argument logging_destination", value=logging_destination, expected_type=type_hints["logging_destination"])
+                check_type(argname="argument scraper_components", value=scraper_components, expected_type=type_hints["scraper_components"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "logging_destination": logging_destination,
+                "scraper_components": scraper_components,
+            }
+
+        @builtins.property
+        def logging_destination(
+            self,
+        ) -> typing.Union[_IResolvable_da3f097b, "CfnScraper.ScraperLoggingDestinationProperty"]:
+            '''Destination for scraper logging.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-scraper-scraperloggingconfiguration.html#cfn-aps-scraper-scraperloggingconfiguration-loggingdestination
+            '''
+            result = self._values.get("logging_destination")
+            assert result is not None, "Required property 'logging_destination' is missing"
+            return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnScraper.ScraperLoggingDestinationProperty"], result)
+
+        @builtins.property
+        def scraper_components(
+            self,
+        ) -> typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnScraper.ScraperComponentProperty"]]]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-scraper-scraperloggingconfiguration.html#cfn-aps-scraper-scraperloggingconfiguration-scrapercomponents
+            '''
+            result = self._values.get("scraper_components")
+            assert result is not None, "Required property 'scraper_components' is missing"
+            return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnScraper.ScraperComponentProperty"]]], 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 "ScraperLoggingConfigurationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_aps.CfnScraper.ScraperLoggingDestinationProperty",
+        jsii_struct_bases=[],
+        name_mapping={"cloud_watch_logs": "cloudWatchLogs"},
+    )
+    class ScraperLoggingDestinationProperty:
+        def __init__(
+            self,
+            *,
+            cloud_watch_logs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnScraper.CloudWatchLogDestinationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        ) -> None:
+            '''The destination where scraper logs are sent.
+
+            :param cloud_watch_logs: The CloudWatch Logs configuration for the scraper logging destination.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-scraper-scraperloggingdestination.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_aps as aps
+                
+                scraper_logging_destination_property = aps.CfnScraper.ScraperLoggingDestinationProperty(
+                    cloud_watch_logs=aps.CfnScraper.CloudWatchLogDestinationProperty(
+                        log_group_arn="logGroupArn"
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__63a27055fededd95d1bc1fba74349c5f0f37894ed254d1e1ce3d670ded2f515f)
+                check_type(argname="argument cloud_watch_logs", value=cloud_watch_logs, expected_type=type_hints["cloud_watch_logs"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if cloud_watch_logs is not None:
+                self._values["cloud_watch_logs"] = cloud_watch_logs
+
+        @builtins.property
+        def cloud_watch_logs(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnScraper.CloudWatchLogDestinationProperty"]]:
+            '''The CloudWatch Logs configuration for the scraper logging destination.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-scraper-scraperloggingdestination.html#cfn-aps-scraper-scraperloggingdestination-cloudwatchlogs
+            '''
+            result = self._values.get("cloud_watch_logs")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnScraper.CloudWatchLogDestinationProperty"]], result)
 
         def __eq__(self, rhs: typing.Any) -> builtins.bool:
             return isinstance(rhs, self.__class__) and rhs._values == self._values
@@ -945,7 +2434,7 @@ class CfnScraper(
             return not (rhs == self)
 
         def __repr__(self) -> str:
-            return "ScrapeConfigurationProperty(%s)" % ", ".join(
+            return "ScraperLoggingDestinationProperty(%s)" % ", ".join(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
@@ -1023,6 +2512,7 @@ class CfnScraper(
         "source": "source",
         "alias": "alias",
         "role_configuration": "roleConfiguration",
+        "scraper_logging_configuration": "scraperLoggingConfiguration",
         "tags": "tags",
     },
 )
@@ -1035,6 +2525,7 @@ class CfnScraperProps:
         source: typing.Union[_IResolvable_da3f097b, typing.Union[CfnScraper.SourceProperty, typing.Dict[builtins.str, typing.Any]]],
         alias: typing.Optional[builtins.str] = None,
         role_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnScraper.RoleConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+        scraper_logging_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnScraper.ScraperLoggingConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
         '''Properties for defining a ``CfnScraper``.
@@ -1043,7 +2534,8 @@ class CfnScraperProps:
         :param scrape_configuration: The configuration in use by the scraper.
         :param source: The Amazon EKS cluster from which the scraper collects metrics.
         :param alias: An optional user-assigned scraper alias.
-        :param role_configuration: Role configuration.
+        :param role_configuration: The role configuration in an Amazon Managed Service for Prometheus scraper.
+        :param scraper_logging_configuration: The definition of logging configuration in an Amazon Managed Service for Prometheus workspace.
         :param tags: (Optional) The list of tag keys and values associated with the scraper.
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-scraper.html
@@ -1080,6 +2572,23 @@ class CfnScraperProps:
                     source_role_arn="sourceRoleArn",
                     target_role_arn="targetRoleArn"
                 ),
+                scraper_logging_configuration=aps.CfnScraper.ScraperLoggingConfigurationProperty(
+                    logging_destination=aps.CfnScraper.ScraperLoggingDestinationProperty(
+                        cloud_watch_logs=aps.CfnScraper.CloudWatchLogDestinationProperty(
+                            log_group_arn="logGroupArn"
+                        )
+                    ),
+                    scraper_components=[aps.CfnScraper.ScraperComponentProperty(
+                        type="type",
+            
+                        # the properties below are optional
+                        config=aps.CfnScraper.ComponentConfigProperty(
+                            options={
+                                "options_key": "options"
+                            }
+                        )
+                    )]
+                ),
                 tags=[CfnTag(
                     key="key",
                     value="value"
@@ -1093,6 +2602,7 @@ class CfnScraperProps:
             check_type(argname="argument source", value=source, expected_type=type_hints["source"])
             check_type(argname="argument alias", value=alias, expected_type=type_hints["alias"])
             check_type(argname="argument role_configuration", value=role_configuration, expected_type=type_hints["role_configuration"])
+            check_type(argname="argument scraper_logging_configuration", value=scraper_logging_configuration, expected_type=type_hints["scraper_logging_configuration"])
             check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "destination": destination,
@@ -1103,6 +2613,8 @@ class CfnScraperProps:
             self._values["alias"] = alias
         if role_configuration is not None:
             self._values["role_configuration"] = role_configuration
+        if scraper_logging_configuration is not None:
+            self._values["scraper_logging_configuration"] = scraper_logging_configuration
         if tags is not None:
             self._values["tags"] = tags
 
@@ -1153,13 +2665,24 @@ class CfnScraperProps:
     def role_configuration(
         self,
     ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnScraper.RoleConfigurationProperty]]:
-        '''Role configuration.
+        '''The role configuration in an Amazon Managed Service for Prometheus scraper.
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-scraper.html#cfn-aps-scraper-roleconfiguration
         '''
         result = self._values.get("role_configuration")
         return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnScraper.RoleConfigurationProperty]], result)
 
+    @builtins.property
+    def scraper_logging_configuration(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnScraper.ScraperLoggingConfigurationProperty]]:
+        '''The definition of logging configuration in an Amazon Managed Service for Prometheus workspace.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-scraper.html#cfn-aps-scraper-scraperloggingconfiguration
+        '''
+        result = self._values.get("scraper_logging_configuration")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnScraper.ScraperLoggingConfigurationProperty]], result)
+
     @builtins.property
     def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
         '''(Optional) The list of tag keys and values associated with the scraper.
@@ -1181,7 +2704,7 @@ class CfnScraperProps:
         )
 
 
-@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
+@jsii.implements(_IInspectable_c2943556, _IWorkspaceRef_d8b2b588, _ITaggable_36806126)
 class CfnWorkspace(
     _CfnResource_9df397a6,
     metaclass=jsii.JSIIMeta,
@@ -1206,6 +2729,16 @@ class CfnWorkspace(
             logging_configuration=aps.CfnWorkspace.LoggingConfigurationProperty(
                 log_group_arn="logGroupArn"
             ),
+            query_logging_configuration=aps.CfnWorkspace.QueryLoggingConfigurationProperty(
+                destinations=[aps.CfnWorkspace.LoggingDestinationProperty(
+                    cloud_watch_logs=aps.CfnWorkspace.CloudWatchLogDestinationProperty(
+                        log_group_arn="logGroupArn"
+                    ),
+                    filters=aps.CfnWorkspace.LoggingFilterProperty(
+                        qsp_threshold=123
+                    )
+                )]
+            ),
             tags=[CfnTag(
                 key="key",
                 value="value"
@@ -1234,16 +2767,19 @@ class CfnWorkspace(
         alias: typing.Optional[builtins.str] = None,
         kms_key_arn: typing.Optional[builtins.str] = None,
         logging_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnWorkspace.LoggingConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        query_logging_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnWorkspace.QueryLoggingConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
         workspace_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnWorkspace.WorkspaceConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
-        '''
+        '''Create a new ``AWS::APS::Workspace``.
+
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
         :param alert_manager_definition: The alert manager definition, a YAML configuration for the alert manager in your Amazon Managed Service for Prometheus workspace. For details about the alert manager definition, see `Creating an alert manager configuration files <https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-alertmanager-config.html>`_ in the *Amazon Managed Service for Prometheus User Guide* . The following example shows part of a CloudFormation YAML file with an embedded alert manager definition (following the ``- |-`` ). ``Workspace: Type: AWS::APS::Workspace .... Properties: .... AlertManagerDefinition: Fn::Sub: - |- alertmanager_config: | templates: - 'default_template' route: receiver: example-sns receivers: - name: example-sns sns_configs: - topic_arn: 'arn:aws:sns:${AWS::Region}:${AWS::AccountId}:${TopicName}' -``
         :param alias: The alias that is assigned to this workspace to help identify it. It does not need to be unique.
         :param kms_key_arn: (optional) The ARN for a customer managed AWS KMS key to use for encrypting data within your workspace. For more information about using your own key in your workspace, see `Encryption at rest <https://docs.aws.amazon.com/prometheus/latest/userguide/encryption-at-rest-Amazon-Service-Prometheus.html>`_ in the *Amazon Managed Service for Prometheus User Guide* .
         :param logging_configuration: Contains information about the logging configuration for the workspace.
+        :param query_logging_configuration: The definition of logging configuration in an Amazon Managed Service for Prometheus workspace.
         :param tags: The list of tag keys and values that are associated with the workspace.
         :param workspace_configuration: Use this structure to define label sets and the ingestion limits for time series that match label sets, and to specify the retention period of the workspace.
         '''
@@ -1256,6 +2792,7 @@ class CfnWorkspace(
             alias=alias,
             kms_key_arn=kms_key_arn,
             logging_configuration=logging_configuration,
+            query_logging_configuration=query_logging_configuration,
             tags=tags,
             workspace_configuration=workspace_configuration,
         )
@@ -1336,6 +2873,12 @@ class CfnWorkspace(
         '''Tag Manager which manages the tags for this resource.'''
         return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))
 
+    @builtins.property
+    @jsii.member(jsii_name="workspaceRef")
+    def workspace_ref(self) -> _WorkspaceReference_4f6a6126:
+        '''A reference to a Workspace resource.'''
+        return typing.cast(_WorkspaceReference_4f6a6126, jsii.get(self, "workspaceRef"))
+
     @builtins.property
     @jsii.member(jsii_name="alertManagerDefinition")
     def alert_manager_definition(self) -> typing.Optional[builtins.str]:
@@ -1393,6 +2936,24 @@ class CfnWorkspace(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "loggingConfiguration", value) # pyright: ignore[reportArgumentType]
 
+    @builtins.property
+    @jsii.member(jsii_name="queryLoggingConfiguration")
+    def query_logging_configuration(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnWorkspace.QueryLoggingConfigurationProperty"]]:
+        '''The definition of logging configuration in an Amazon Managed Service for Prometheus workspace.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnWorkspace.QueryLoggingConfigurationProperty"]], jsii.get(self, "queryLoggingConfiguration"))
+
+    @query_logging_configuration.setter
+    def query_logging_configuration(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnWorkspace.QueryLoggingConfigurationProperty"]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__6591166b06ced49bc35c6390884a7a1c30cea4102022183768ac43e25c00f9fc)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "queryLoggingConfiguration", value) # pyright: ignore[reportArgumentType]
+
     @builtins.property
     @jsii.member(jsii_name="tagsRaw")
     def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
@@ -1424,6 +2985,58 @@ class CfnWorkspace(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "workspaceConfiguration", value) # pyright: ignore[reportArgumentType]
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_aps.CfnWorkspace.CloudWatchLogDestinationProperty",
+        jsii_struct_bases=[],
+        name_mapping={"log_group_arn": "logGroupArn"},
+    )
+    class CloudWatchLogDestinationProperty:
+        def __init__(self, *, log_group_arn: builtins.str) -> None:
+            '''Configuration details for logging to CloudWatch Logs.
+
+            :param log_group_arn: The ARN of the CloudWatch log group.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-cloudwatchlogdestination.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_aps as aps
+                
+                cloud_watch_log_destination_property = aps.CfnWorkspace.CloudWatchLogDestinationProperty(
+                    log_group_arn="logGroupArn"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__925c774442f9150193a5d3bfa3fb05562aec6581139c1378b5f09e1c30fb40ee)
+                check_type(argname="argument log_group_arn", value=log_group_arn, expected_type=type_hints["log_group_arn"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "log_group_arn": log_group_arn,
+            }
+
+        @builtins.property
+        def log_group_arn(self) -> builtins.str:
+            '''The ARN of the CloudWatch log group.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-cloudwatchlogdestination.html#cfn-aps-workspace-cloudwatchlogdestination-loggrouparn
+            '''
+            result = self._values.get("log_group_arn")
+            assert result is not None, "Required property 'log_group_arn' is missing"
+            return typing.cast(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 "CloudWatchLogDestinationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_aps.CfnWorkspace.LabelProperty",
         jsii_struct_bases=[],
@@ -1541,30 +3154,248 @@ class CfnWorkspace(
             return not (rhs == self)
 
         def __repr__(self) -> str:
-            return "LimitsPerLabelSetEntryProperty(%s)" % ", ".join(
+            return "LimitsPerLabelSetEntryProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_aps.CfnWorkspace.LimitsPerLabelSetProperty",
+        jsii_struct_bases=[],
+        name_mapping={"label_set": "labelSet", "limits": "limits"},
+    )
+    class LimitsPerLabelSetProperty:
+        def __init__(
+            self,
+            *,
+            label_set: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnWorkspace.LabelProperty", typing.Dict[builtins.str, typing.Any]]]]],
+            limits: typing.Union[_IResolvable_da3f097b, typing.Union["CfnWorkspace.LimitsPerLabelSetEntryProperty", typing.Dict[builtins.str, typing.Any]]],
+        ) -> None:
+            '''This defines a label set for the workspace, and defines the ingestion limit for active time series that match that label set.
+
+            Each label name in a label set must be unique.
+
+            :param label_set: This defines one label set that will have an enforced ingestion limit. You can set ingestion limits on time series that match defined label sets, to help prevent a workspace from being overwhelmed with unexpected spikes in time series ingestion. Label values accept all UTF-8 characters with one exception. If the label name is metric name label ``__ *name* __`` , then the *metric* part of the name must conform to the following pattern: ``[a-zA-Z_:][a-zA-Z0-9_:]*``
+            :param limits: This structure contains the information about the limits that apply to time series that match this label set.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-limitsperlabelset.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_aps as aps
+                
+                limits_per_label_set_property = aps.CfnWorkspace.LimitsPerLabelSetProperty(
+                    label_set=[aps.CfnWorkspace.LabelProperty(
+                        name="name",
+                        value="value"
+                    )],
+                    limits=aps.CfnWorkspace.LimitsPerLabelSetEntryProperty(
+                        max_series=123
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__3d8045fc76bdfc4af5de994e0ebe3331fd81257f1ae53d90373a7ad960b0bca7)
+                check_type(argname="argument label_set", value=label_set, expected_type=type_hints["label_set"])
+                check_type(argname="argument limits", value=limits, expected_type=type_hints["limits"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "label_set": label_set,
+                "limits": limits,
+            }
+
+        @builtins.property
+        def label_set(
+            self,
+        ) -> typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnWorkspace.LabelProperty"]]]:
+            '''This defines one label set that will have an enforced ingestion limit.
+
+            You can set ingestion limits on time series that match defined label sets, to help prevent a workspace from being overwhelmed with unexpected spikes in time series ingestion.
+
+            Label values accept all UTF-8 characters with one exception. If the label name is metric name label ``__ *name* __`` , then the *metric* part of the name must conform to the following pattern: ``[a-zA-Z_:][a-zA-Z0-9_:]*``
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-limitsperlabelset.html#cfn-aps-workspace-limitsperlabelset-labelset
+            '''
+            result = self._values.get("label_set")
+            assert result is not None, "Required property 'label_set' is missing"
+            return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnWorkspace.LabelProperty"]]], result)
+
+        @builtins.property
+        def limits(
+            self,
+        ) -> typing.Union[_IResolvable_da3f097b, "CfnWorkspace.LimitsPerLabelSetEntryProperty"]:
+            '''This structure contains the information about the limits that apply to time series that match this label set.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-limitsperlabelset.html#cfn-aps-workspace-limitsperlabelset-limits
+            '''
+            result = self._values.get("limits")
+            assert result is not None, "Required property 'limits' is missing"
+            return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnWorkspace.LimitsPerLabelSetEntryProperty"], 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 "LimitsPerLabelSetProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_aps.CfnWorkspace.LoggingConfigurationProperty",
+        jsii_struct_bases=[],
+        name_mapping={"log_group_arn": "logGroupArn"},
+    )
+    class LoggingConfigurationProperty:
+        def __init__(
+            self,
+            *,
+            log_group_arn: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''Contains information about the rules and alerting logging configuration for the workspace.
+
+            .. epigraph::
+
+               These logging configurations are only for rules and alerting logs.
+
+            :param log_group_arn: The ARN of the CloudWatch log group to which the vended log data will be published. This log group must exist prior to calling this operation.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-loggingconfiguration.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_aps as aps
+                
+                logging_configuration_property = aps.CfnWorkspace.LoggingConfigurationProperty(
+                    log_group_arn="logGroupArn"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__fa0678eca2188c6c3220d708f7d16298acecab165f03de8b400d1fada6a4b9d9)
+                check_type(argname="argument log_group_arn", value=log_group_arn, expected_type=type_hints["log_group_arn"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if log_group_arn is not None:
+                self._values["log_group_arn"] = log_group_arn
+
+        @builtins.property
+        def log_group_arn(self) -> typing.Optional[builtins.str]:
+            '''The ARN of the CloudWatch log group to which the vended log data will be published.
+
+            This log group must exist prior to calling this operation.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-loggingconfiguration.html#cfn-aps-workspace-loggingconfiguration-loggrouparn
+            '''
+            result = self._values.get("log_group_arn")
+            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 "LoggingConfigurationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_aps.CfnWorkspace.LoggingDestinationProperty",
+        jsii_struct_bases=[],
+        name_mapping={"cloud_watch_logs": "cloudWatchLogs", "filters": "filters"},
+    )
+    class LoggingDestinationProperty:
+        def __init__(
+            self,
+            *,
+            cloud_watch_logs: typing.Union[_IResolvable_da3f097b, typing.Union["CfnWorkspace.CloudWatchLogDestinationProperty", typing.Dict[builtins.str, typing.Any]]],
+            filters: typing.Union[_IResolvable_da3f097b, typing.Union["CfnWorkspace.LoggingFilterProperty", typing.Dict[builtins.str, typing.Any]]],
+        ) -> None:
+            '''The logging destination in an Amazon Managed Service for Prometheus workspace.
+
+            :param cloud_watch_logs: Configuration details for logging to CloudWatch Logs.
+            :param filters: Filtering criteria that determine which queries are logged.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-loggingdestination.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_aps as aps
+                
+                logging_destination_property = aps.CfnWorkspace.LoggingDestinationProperty(
+                    cloud_watch_logs=aps.CfnWorkspace.CloudWatchLogDestinationProperty(
+                        log_group_arn="logGroupArn"
+                    ),
+                    filters=aps.CfnWorkspace.LoggingFilterProperty(
+                        qsp_threshold=123
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__cce5991812152322bf70db3d7cea0d7bb3cda26bb6b0e82d9bd091ef05995168)
+                check_type(argname="argument cloud_watch_logs", value=cloud_watch_logs, expected_type=type_hints["cloud_watch_logs"])
+                check_type(argname="argument filters", value=filters, expected_type=type_hints["filters"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "cloud_watch_logs": cloud_watch_logs,
+                "filters": filters,
+            }
+
+        @builtins.property
+        def cloud_watch_logs(
+            self,
+        ) -> typing.Union[_IResolvable_da3f097b, "CfnWorkspace.CloudWatchLogDestinationProperty"]:
+            '''Configuration details for logging to CloudWatch Logs.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-loggingdestination.html#cfn-aps-workspace-loggingdestination-cloudwatchlogs
+            '''
+            result = self._values.get("cloud_watch_logs")
+            assert result is not None, "Required property 'cloud_watch_logs' is missing"
+            return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnWorkspace.CloudWatchLogDestinationProperty"], result)
+
+        @builtins.property
+        def filters(
+            self,
+        ) -> typing.Union[_IResolvable_da3f097b, "CfnWorkspace.LoggingFilterProperty"]:
+            '''Filtering criteria that determine which queries are logged.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-loggingdestination.html#cfn-aps-workspace-loggingdestination-filters
+            '''
+            result = self._values.get("filters")
+            assert result is not None, "Required property 'filters' is missing"
+            return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnWorkspace.LoggingFilterProperty"], 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 "LoggingDestinationProperty(%s)" % ", ".join(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
     @jsii.data_type(
-        jsii_type="aws-cdk-lib.aws_aps.CfnWorkspace.LimitsPerLabelSetProperty",
+        jsii_type="aws-cdk-lib.aws_aps.CfnWorkspace.LoggingFilterProperty",
         jsii_struct_bases=[],
-        name_mapping={"label_set": "labelSet", "limits": "limits"},
+        name_mapping={"qsp_threshold": "qspThreshold"},
     )
-    class LimitsPerLabelSetProperty:
-        def __init__(
-            self,
-            *,
-            label_set: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnWorkspace.LabelProperty", typing.Dict[builtins.str, typing.Any]]]]],
-            limits: typing.Union[_IResolvable_da3f097b, typing.Union["CfnWorkspace.LimitsPerLabelSetEntryProperty", typing.Dict[builtins.str, typing.Any]]],
-        ) -> None:
-            '''This defines a label set for the workspace, and defines the ingestion limit for active time series that match that label set.
-
-            Each label name in a label set must be unique.
+    class LoggingFilterProperty:
+        def __init__(self, *, qsp_threshold: jsii.Number) -> None:
+            '''Filtering criteria that determine which queries are logged.
 
-            :param label_set: This defines one label set that will have an enforced ingestion limit. You can set ingestion limits on time series that match defined label sets, to help prevent a workspace from being overwhelmed with unexpected spikes in time series ingestion. Label values accept all UTF-8 characters with one exception. If the label name is metric name label ``__ *name* __`` , then the *metric* part of the name must conform to the following pattern: ``[a-zA-Z_:][a-zA-Z0-9_:]*``
-            :param limits: This structure contains the information about the limits that apply to time series that match this label set.
+            :param qsp_threshold: The Query Samples Processed (QSP) threshold above which queries will be logged. Queries processing more samples than this threshold will be captured in logs.
 
-            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-limitsperlabelset.html
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-loggingfilter.html
             :exampleMetadata: fixture=_generated
 
             Example::
@@ -1573,52 +3404,28 @@ class CfnWorkspace(
                 # The values are placeholders you should change.
                 from aws_cdk import aws_aps as aps
                 
-                limits_per_label_set_property = aps.CfnWorkspace.LimitsPerLabelSetProperty(
-                    label_set=[aps.CfnWorkspace.LabelProperty(
-                        name="name",
-                        value="value"
-                    )],
-                    limits=aps.CfnWorkspace.LimitsPerLabelSetEntryProperty(
-                        max_series=123
-                    )
+                logging_filter_property = aps.CfnWorkspace.LoggingFilterProperty(
+                    qsp_threshold=123
                 )
             '''
             if __debug__:
-                type_hints = typing.get_type_hints(_typecheckingstub__3d8045fc76bdfc4af5de994e0ebe3331fd81257f1ae53d90373a7ad960b0bca7)
-                check_type(argname="argument label_set", value=label_set, expected_type=type_hints["label_set"])
-                check_type(argname="argument limits", value=limits, expected_type=type_hints["limits"])
+                type_hints = typing.get_type_hints(_typecheckingstub__8f1710f9a533b3c78aa9735866c9480208fe7ceb912d68581872b145d4c634fd)
+                check_type(argname="argument qsp_threshold", value=qsp_threshold, expected_type=type_hints["qsp_threshold"])
             self._values: typing.Dict[builtins.str, typing.Any] = {
-                "label_set": label_set,
-                "limits": limits,
+                "qsp_threshold": qsp_threshold,
             }
 
         @builtins.property
-        def label_set(
-            self,
-        ) -> typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnWorkspace.LabelProperty"]]]:
-            '''This defines one label set that will have an enforced ingestion limit.
-
-            You can set ingestion limits on time series that match defined label sets, to help prevent a workspace from being overwhelmed with unexpected spikes in time series ingestion.
-
-            Label values accept all UTF-8 characters with one exception. If the label name is metric name label ``__ *name* __`` , then the *metric* part of the name must conform to the following pattern: ``[a-zA-Z_:][a-zA-Z0-9_:]*``
-
-            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-limitsperlabelset.html#cfn-aps-workspace-limitsperlabelset-labelset
-            '''
-            result = self._values.get("label_set")
-            assert result is not None, "Required property 'label_set' is missing"
-            return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnWorkspace.LabelProperty"]]], result)
+        def qsp_threshold(self) -> jsii.Number:
+            '''The Query Samples Processed (QSP) threshold above which queries will be logged.
 
-        @builtins.property
-        def limits(
-            self,
-        ) -> typing.Union[_IResolvable_da3f097b, "CfnWorkspace.LimitsPerLabelSetEntryProperty"]:
-            '''This structure contains the information about the limits that apply to time series that match this label set.
+            Queries processing more samples than this threshold will be captured in logs.
 
-            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-limitsperlabelset.html#cfn-aps-workspace-limitsperlabelset-limits
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-loggingfilter.html#cfn-aps-workspace-loggingfilter-qspthreshold
             '''
-            result = self._values.get("limits")
-            assert result is not None, "Required property 'limits' is missing"
-            return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnWorkspace.LimitsPerLabelSetEntryProperty"], result)
+            result = self._values.get("qsp_threshold")
+            assert result is not None, "Required property 'qsp_threshold' is missing"
+            return typing.cast(jsii.Number, result)
 
         def __eq__(self, rhs: typing.Any) -> builtins.bool:
             return isinstance(rhs, self.__class__) and rhs._values == self._values
@@ -1627,26 +3434,26 @@ class CfnWorkspace(
             return not (rhs == self)
 
         def __repr__(self) -> str:
-            return "LimitsPerLabelSetProperty(%s)" % ", ".join(
+            return "LoggingFilterProperty(%s)" % ", ".join(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
     @jsii.data_type(
-        jsii_type="aws-cdk-lib.aws_aps.CfnWorkspace.LoggingConfigurationProperty",
+        jsii_type="aws-cdk-lib.aws_aps.CfnWorkspace.QueryLoggingConfigurationProperty",
         jsii_struct_bases=[],
-        name_mapping={"log_group_arn": "logGroupArn"},
+        name_mapping={"destinations": "destinations"},
     )
-    class LoggingConfigurationProperty:
+    class QueryLoggingConfigurationProperty:
         def __init__(
             self,
             *,
-            log_group_arn: typing.Optional[builtins.str] = None,
+            destinations: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnWorkspace.LoggingDestinationProperty", typing.Dict[builtins.str, typing.Any]]]]],
         ) -> None:
-            '''Contains information about the logging configuration for the workspace.
+            '''The query logging configuration in an Amazon Managed Service for Prometheus workspace.
 
-            :param log_group_arn: The ARN of the CloudWatch log group to which the vended log data will be published. This log group must exist prior to calling this operation.
+            :param destinations: Defines a destination and its associated filtering criteria for query logging.
 
-            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-loggingconfiguration.html
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-queryloggingconfiguration.html
             :exampleMetadata: fixture=_generated
 
             Example::
@@ -1655,27 +3462,35 @@ class CfnWorkspace(
                 # The values are placeholders you should change.
                 from aws_cdk import aws_aps as aps
                 
-                logging_configuration_property = aps.CfnWorkspace.LoggingConfigurationProperty(
-                    log_group_arn="logGroupArn"
+                query_logging_configuration_property = aps.CfnWorkspace.QueryLoggingConfigurationProperty(
+                    destinations=[aps.CfnWorkspace.LoggingDestinationProperty(
+                        cloud_watch_logs=aps.CfnWorkspace.CloudWatchLogDestinationProperty(
+                            log_group_arn="logGroupArn"
+                        ),
+                        filters=aps.CfnWorkspace.LoggingFilterProperty(
+                            qsp_threshold=123
+                        )
+                    )]
                 )
             '''
             if __debug__:
-                type_hints = typing.get_type_hints(_typecheckingstub__fa0678eca2188c6c3220d708f7d16298acecab165f03de8b400d1fada6a4b9d9)
-                check_type(argname="argument log_group_arn", value=log_group_arn, expected_type=type_hints["log_group_arn"])
-            self._values: typing.Dict[builtins.str, typing.Any] = {}
-            if log_group_arn is not None:
-                self._values["log_group_arn"] = log_group_arn
+                type_hints = typing.get_type_hints(_typecheckingstub__59e9b7a5bb1ecf6d3e6bf0c4d2f497bea98d1fe68b36d502a98c9b336781a58a)
+                check_type(argname="argument destinations", value=destinations, expected_type=type_hints["destinations"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "destinations": destinations,
+            }
 
         @builtins.property
-        def log_group_arn(self) -> typing.Optional[builtins.str]:
-            '''The ARN of the CloudWatch log group to which the vended log data will be published.
-
-            This log group must exist prior to calling this operation.
+        def destinations(
+            self,
+        ) -> typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnWorkspace.LoggingDestinationProperty"]]]:
+            '''Defines a destination and its associated filtering criteria for query logging.
 
-            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-loggingconfiguration.html#cfn-aps-workspace-loggingconfiguration-loggrouparn
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-aps-workspace-queryloggingconfiguration.html#cfn-aps-workspace-queryloggingconfiguration-destinations
             '''
-            result = self._values.get("log_group_arn")
-            return typing.cast(typing.Optional[builtins.str], result)
+            result = self._values.get("destinations")
+            assert result is not None, "Required property 'destinations' is missing"
+            return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnWorkspace.LoggingDestinationProperty"]]], result)
 
         def __eq__(self, rhs: typing.Any) -> builtins.bool:
             return isinstance(rhs, self.__class__) and rhs._values == self._values
@@ -1684,7 +3499,7 @@ class CfnWorkspace(
             return not (rhs == self)
 
         def __repr__(self) -> str:
-            return "LoggingConfigurationProperty(%s)" % ", ".join(
+            return "QueryLoggingConfigurationProperty(%s)" % ", ".join(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
@@ -1782,6 +3597,7 @@ class CfnWorkspace(
         "alias": "alias",
         "kms_key_arn": "kmsKeyArn",
         "logging_configuration": "loggingConfiguration",
+        "query_logging_configuration": "queryLoggingConfiguration",
         "tags": "tags",
         "workspace_configuration": "workspaceConfiguration",
     },
@@ -1794,6 +3610,7 @@ class CfnWorkspaceProps:
         alias: typing.Optional[builtins.str] = None,
         kms_key_arn: typing.Optional[builtins.str] = None,
         logging_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnWorkspace.LoggingConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+        query_logging_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnWorkspace.QueryLoggingConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
         workspace_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnWorkspace.WorkspaceConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
@@ -1803,6 +3620,7 @@ class CfnWorkspaceProps:
         :param alias: The alias that is assigned to this workspace to help identify it. It does not need to be unique.
         :param kms_key_arn: (optional) The ARN for a customer managed AWS KMS key to use for encrypting data within your workspace. For more information about using your own key in your workspace, see `Encryption at rest <https://docs.aws.amazon.com/prometheus/latest/userguide/encryption-at-rest-Amazon-Service-Prometheus.html>`_ in the *Amazon Managed Service for Prometheus User Guide* .
         :param logging_configuration: Contains information about the logging configuration for the workspace.
+        :param query_logging_configuration: The definition of logging configuration in an Amazon Managed Service for Prometheus workspace.
         :param tags: The list of tag keys and values that are associated with the workspace.
         :param workspace_configuration: Use this structure to define label sets and the ingestion limits for time series that match label sets, and to specify the retention period of the workspace.
 
@@ -1822,6 +3640,16 @@ class CfnWorkspaceProps:
                 logging_configuration=aps.CfnWorkspace.LoggingConfigurationProperty(
                     log_group_arn="logGroupArn"
                 ),
+                query_logging_configuration=aps.CfnWorkspace.QueryLoggingConfigurationProperty(
+                    destinations=[aps.CfnWorkspace.LoggingDestinationProperty(
+                        cloud_watch_logs=aps.CfnWorkspace.CloudWatchLogDestinationProperty(
+                            log_group_arn="logGroupArn"
+                        ),
+                        filters=aps.CfnWorkspace.LoggingFilterProperty(
+                            qsp_threshold=123
+                        )
+                    )]
+                ),
                 tags=[CfnTag(
                     key="key",
                     value="value"
@@ -1846,6 +3674,7 @@ class CfnWorkspaceProps:
             check_type(argname="argument alias", value=alias, expected_type=type_hints["alias"])
             check_type(argname="argument kms_key_arn", value=kms_key_arn, expected_type=type_hints["kms_key_arn"])
             check_type(argname="argument logging_configuration", value=logging_configuration, expected_type=type_hints["logging_configuration"])
+            check_type(argname="argument query_logging_configuration", value=query_logging_configuration, expected_type=type_hints["query_logging_configuration"])
             check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
             check_type(argname="argument workspace_configuration", value=workspace_configuration, expected_type=type_hints["workspace_configuration"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
@@ -1857,6 +3686,8 @@ class CfnWorkspaceProps:
             self._values["kms_key_arn"] = kms_key_arn
         if logging_configuration is not None:
             self._values["logging_configuration"] = logging_configuration
+        if query_logging_configuration is not None:
+            self._values["query_logging_configuration"] = query_logging_configuration
         if tags is not None:
             self._values["tags"] = tags
         if workspace_configuration is not None:
@@ -1910,6 +3741,17 @@ class CfnWorkspaceProps:
         result = self._values.get("logging_configuration")
         return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnWorkspace.LoggingConfigurationProperty]], result)
 
+    @builtins.property
+    def query_logging_configuration(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnWorkspace.QueryLoggingConfigurationProperty]]:
+        '''The definition of logging configuration in an Amazon Managed Service for Prometheus workspace.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-aps-workspace.html#cfn-aps-workspace-queryloggingconfiguration
+        '''
+        result = self._values.get("query_logging_configuration")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnWorkspace.QueryLoggingConfigurationProperty]], result)
+
     @builtins.property
     def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
         '''The list of tag keys and values that are associated with the workspace.
@@ -1943,6 +3785,10 @@ class CfnWorkspaceProps:
 
 
 __all__ = [
+    "CfnAnomalyDetector",
+    "CfnAnomalyDetectorProps",
+    "CfnResourcePolicy",
+    "CfnResourcePolicyProps",
     "CfnRuleGroupsNamespace",
     "CfnRuleGroupsNamespaceProps",
     "CfnScraper",
@@ -1953,6 +3799,172 @@ __all__ = [
 
 publication.publish()
 
+def _typecheckingstub__58b3184629f18780da9f7c9eb2f8acdbdbb5190c9fc3ae41fdbbe34341ba0f26(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    alias: builtins.str,
+    configuration: typing.Union[_IResolvable_da3f097b, typing.Union[CfnAnomalyDetector.AnomalyDetectorConfigurationProperty, typing.Dict[builtins.str, typing.Any]]],
+    workspace: builtins.str,
+    evaluation_interval_in_seconds: typing.Optional[jsii.Number] = None,
+    labels: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnAnomalyDetector.LabelProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    missing_data_action: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnAnomalyDetector.MissingDataActionProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__36a9fa3c67c466703717001e2774dacca3fa612b6ec02f8b6361ad6736da0ec7(
+    inspector: _TreeInspector_488e0dd5,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__1edc3473fdf33536207faf87047c2bef23ac4e4aecad53d1e0338308f0e5ab91(
+    props: typing.Mapping[builtins.str, typing.Any],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__fe3aa1b72ccc7677675b2ae76ae8e5e1dfd2146dae8eba7520a981184cdf780d(
+    value: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__1394fe6b497d7add7f3c437f746b83234bfd1714418b007d2ca77fcaf2e486fa(
+    value: typing.Union[_IResolvable_da3f097b, CfnAnomalyDetector.AnomalyDetectorConfigurationProperty],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__51d01d3c64410491a2005087b379e01fe1749ffd4be8e8dae194b7cc8e5e19b8(
+    value: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__ce3cb5189478c72429dee4d6fa1ed9635e537559491f15b775c279a89020cb75(
+    value: typing.Optional[jsii.Number],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__0d15555eb30ee6b4decc1dba71c708714ce1a7f00e658c2ce9c617f35dbea119(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnAnomalyDetector.LabelProperty]]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__e639ced06e0101ba2e1108f2a5748e988f60e8c6ecadbb32ca0f2dc6162a53e8(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnAnomalyDetector.MissingDataActionProperty]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__dc8b42c0f027d8c1c104a6037d9c3752efbfb2ae169c30d63f35dee5bad63b3f(
+    value: typing.Optional[typing.List[_CfnTag_f6864754]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__aca672630a5e19c23bb68b82c63c873a7687610464d166cef0da5d6cde142082(
+    *,
+    random_cut_forest: typing.Union[_IResolvable_da3f097b, typing.Union[CfnAnomalyDetector.RandomCutForestConfigurationProperty, typing.Dict[builtins.str, typing.Any]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__e3e1cf276ea5a24efc7ebe9d526fad4e86dd66a3f55ea5a0dcb3a617b8d62dff(
+    *,
+    amount: typing.Optional[jsii.Number] = None,
+    ratio: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__3f784d604d60c49dd5fb567dcfedcd9d16e2ce47ba899589a373c9322818035a(
+    *,
+    key: builtins.str,
+    value: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__e5b8457b72ba87aa14000e26b68e021fa4b19e4e88f3a022910dcd18542039d0(
+    *,
+    mark_as_anomaly: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+    skip: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__83993f42a131a948093792cb8cd7b4f710c6b4dffce6b17f386497f1cbe514ea(
+    *,
+    query: builtins.str,
+    ignore_near_expected_from_above: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnAnomalyDetector.IgnoreNearExpectedProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    ignore_near_expected_from_below: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnAnomalyDetector.IgnoreNearExpectedProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    sample_size: typing.Optional[jsii.Number] = None,
+    shingle_size: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__be017a909bcb870b1880c9bb2c099abc51df504e0f9199ca315deb7fa50b9d6b(
+    *,
+    alias: builtins.str,
+    configuration: typing.Union[_IResolvable_da3f097b, typing.Union[CfnAnomalyDetector.AnomalyDetectorConfigurationProperty, typing.Dict[builtins.str, typing.Any]]],
+    workspace: builtins.str,
+    evaluation_interval_in_seconds: typing.Optional[jsii.Number] = None,
+    labels: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnAnomalyDetector.LabelProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    missing_data_action: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnAnomalyDetector.MissingDataActionProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__54f89d9ee1d6d400f40f83801fe40dee056ce969e9e0501ca1390285aab7cb82(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    policy_document: builtins.str,
+    workspace_arn: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__7fd684bb5425ae9b9586530c2118e55043226673b8740171d3f7c2b1fbd03b3d(
+    inspector: _TreeInspector_488e0dd5,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__96c6a584b0420e6cc37e76ad4b000bc6d8f4137f577bf7075b4ec87bab8717d9(
+    props: typing.Mapping[builtins.str, typing.Any],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__d726921aa53fc43f461134d2df5d60edb5d56b4fa67ef6e4e82d305af7b7eba5(
+    value: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__2f020f5d54f91c35f0b4332b16391ef6561cfc07a46cc5fc1e48d4acdb82a4b8(
+    value: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__bb05747fc90b1776c66fd40ec5d261399f93ac6b367fc973d5df8b912bd30997(
+    *,
+    policy_document: builtins.str,
+    workspace_arn: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__02d681a4d4a1e9d9052c98f45bf8b21257e825ee8185b30ea4b6f887fc7416b1(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
@@ -2020,6 +4032,7 @@ def _typecheckingstub__4d4cb1653b22b80f73c5fa4972418519c1d58f8ac033d22184f1b74ee
     source: typing.Union[_IResolvable_da3f097b, typing.Union[CfnScraper.SourceProperty, typing.Dict[builtins.str, typing.Any]]],
     alias: typing.Optional[builtins.str] = None,
     role_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnScraper.RoleConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    scraper_logging_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnScraper.ScraperLoggingConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
     """Type checking stubs"""
@@ -2067,6 +4080,12 @@ def _typecheckingstub__a8492f7c00f66de3309f136730786a3ad81d27f787146130fdb2b6191
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__98c937c38a5c278540b0a6d9654c4dc0d8dbc46a2f3145fd9275f2a8fd9ce000(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnScraper.ScraperLoggingConfigurationProperty]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__265ada3fe1d3014c11a5af4d87c8e4b691d29a917e8643b804a82b7c3223573f(
     value: typing.Optional[typing.List[_CfnTag_f6864754]],
 ) -> None:
@@ -2080,6 +4099,20 @@ def _typecheckingstub__02c8f0a43ed30375a3d1b283c2450f310915b0f0fcff6103d168cb18a
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__d4d1b8a234d9b0461189ac94d16b7043b8e40fc1a62680a811ba8396bc54a5d6(
+    *,
+    log_group_arn: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__c81abd8a9526f73204a9bfa774d69e9b3ec81f7592dafabd756679cc66dcb1e1(
+    *,
+    options: typing.Optional[typing.Union[typing.Mapping[builtins.str, builtins.str], _IResolvable_da3f097b]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__e9dfeb013903b3b566e12e34ac903da7aaad96412ee8622e798d0f4931b78c31(
     *,
     amp_configuration: typing.Union[_IResolvable_da3f097b, typing.Union[CfnScraper.AmpConfigurationProperty, typing.Dict[builtins.str, typing.Any]]],
@@ -2111,6 +4144,29 @@ def _typecheckingstub__61507a1463486662c27c8fec99a5cb181f22e5f346b7bb6d10823ad9b
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__be259f573540cfe3fb130cbc10c656811dffac0fb6663b27b9f4982549990b6a(
+    *,
+    type: builtins.str,
+    config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnScraper.ComponentConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__ea5221003b2ff43404935c67045669a8a84790d807c849eadd6df28ea9b60feb(
+    *,
+    logging_destination: typing.Union[_IResolvable_da3f097b, typing.Union[CfnScraper.ScraperLoggingDestinationProperty, typing.Dict[builtins.str, typing.Any]]],
+    scraper_components: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnScraper.ScraperComponentProperty, typing.Dict[builtins.str, typing.Any]]]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__63a27055fededd95d1bc1fba74349c5f0f37894ed254d1e1ce3d670ded2f515f(
+    *,
+    cloud_watch_logs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnScraper.CloudWatchLogDestinationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__655e83ac40d7d6fcc3362aa2c25fcfadc0beb5744ef393de105d7d152821a330(
     *,
     eks_configuration: typing.Union[_IResolvable_da3f097b, typing.Union[CfnScraper.EksConfigurationProperty, typing.Dict[builtins.str, typing.Any]]],
@@ -2125,6 +4181,7 @@ def _typecheckingstub__f302dfc2aa92636b313e32f5d91a0ccfd79ebde0259b977f6291d4c83
     source: typing.Union[_IResolvable_da3f097b, typing.Union[CfnScraper.SourceProperty, typing.Dict[builtins.str, typing.Any]]],
     alias: typing.Optional[builtins.str] = None,
     role_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnScraper.RoleConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    scraper_logging_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnScraper.ScraperLoggingConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
     """Type checking stubs"""
@@ -2138,6 +4195,7 @@ def _typecheckingstub__0d7d4de6c2c3c0a6cc1f746f35f29f98344da5c5d59e48a9d1e788ab8
     alias: typing.Optional[builtins.str] = None,
     kms_key_arn: typing.Optional[builtins.str] = None,
     logging_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnWorkspace.LoggingConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    query_logging_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnWorkspace.QueryLoggingConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     workspace_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnWorkspace.WorkspaceConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
@@ -2180,6 +4238,12 @@ def _typecheckingstub__ab06dccfc037b2ba3e02b4a3154224a63edcfe3fc06381ff9162c2c33
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__6591166b06ced49bc35c6390884a7a1c30cea4102022183768ac43e25c00f9fc(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnWorkspace.QueryLoggingConfigurationProperty]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__fb4e1977fb1f7aad47144a42af408e41c9d01794f3569a614a9ed54effb1c1e5(
     value: typing.Optional[typing.List[_CfnTag_f6864754]],
 ) -> None:
@@ -2192,6 +4256,13 @@ def _typecheckingstub__7dc44ff5af32b5cdcf5234cdf89709e32cf5a9217d64f6f2b66251910
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__925c774442f9150193a5d3bfa3fb05562aec6581139c1378b5f09e1c30fb40ee(
+    *,
+    log_group_arn: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__b34eb56a3257d05ed157ec9252590ce797546e9e647035e7f3e639a6629c1cd3(
     *,
     name: builtins.str,
@@ -2222,6 +4293,28 @@ def _typecheckingstub__fa0678eca2188c6c3220d708f7d16298acecab165f03de8b400d1fada
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__cce5991812152322bf70db3d7cea0d7bb3cda26bb6b0e82d9bd091ef05995168(
+    *,
+    cloud_watch_logs: typing.Union[_IResolvable_da3f097b, typing.Union[CfnWorkspace.CloudWatchLogDestinationProperty, typing.Dict[builtins.str, typing.Any]]],
+    filters: typing.Union[_IResolvable_da3f097b, typing.Union[CfnWorkspace.LoggingFilterProperty, typing.Dict[builtins.str, typing.Any]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__8f1710f9a533b3c78aa9735866c9480208fe7ceb912d68581872b145d4c634fd(
+    *,
+    qsp_threshold: jsii.Number,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__59e9b7a5bb1ecf6d3e6bf0c4d2f497bea98d1fe68b36d502a98c9b336781a58a(
+    *,
+    destinations: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnWorkspace.LoggingDestinationProperty, typing.Dict[builtins.str, typing.Any]]]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__8d8bd4b9a39be1594ef4681992e92f89f24816c775c0e0c40e340be13e59392a(
     *,
     limits_per_label_sets: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnWorkspace.LimitsPerLabelSetProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
@@ -2236,6 +4329,7 @@ def _typecheckingstub__98e95bd874171795b8c6f6104e5fee9fa1d8f50cb6e1edc6d2cc01a77
     alias: typing.Optional[builtins.str] = None,
     kms_key_arn: typing.Optional[builtins.str] = None,
     logging_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnWorkspace.LoggingConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    query_logging_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnWorkspace.QueryLoggingConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     workspace_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnWorkspace.WorkspaceConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None: