aws-cdk-lib 2.139.1__py3-none-any.whl → 2.141.0__py3-none-any.whl

aws_cdk/aws_ecr/__init__.py

@@ -219,6 +219,27 @@ repository.add_to_resource_policy(iam.PolicyStatement(
     principals=[iam.AnyPrincipal()]
 ))
 ```
+
+## CloudWatch event rules
+
+You can publish repository events to a CloudWatch event rule with `onEvent`:
+
+```python
+import aws_cdk.aws_lambda as lambda_
+from aws_cdk.aws_events_targets import LambdaFunction
+
+
+repo = ecr.Repository(self, "Repo")
+lambda_handler = lambda_.Function(self, "LambdaFunction",
+    runtime=lambda_.Runtime.PYTHON_3_12,
+    code=lambda_.Code.from_inline("# dummy func"),
+    handler="index.handler"
+)
+
+repo.on_event("OnEventTargetLambda",
+    target=LambdaFunction(lambda_handler)
+)
+```
 '''
 from pkgutil import extend_path
 __path__ = extend_path(__path__, __name__)
@@ -4664,15 +4685,19 @@ class Repository(
 
     Example::
 
-        import aws_cdk.aws_ecr as ecr
+        import aws_cdk.aws_lambda as lambda_
+        from aws_cdk.aws_events_targets import LambdaFunction
         
         
-        apprunner.Service(self, "Service",
-            source=apprunner.Source.from_ecr(
-                image_configuration=apprunner.ImageConfiguration(port=80),
-                repository=ecr.Repository.from_repository_name(self, "NginxRepository", "nginx"),
-                tag_or_digest="latest"
-            )
+        repo = ecr.Repository(self, "Repo")
+        lambda_handler = lambda_.Function(self, "LambdaFunction",
+            runtime=lambda_.Runtime.PYTHON_3_12,
+            code=lambda_.Code.from_inline("# dummy func"),
+            handler="index.handler"
+        )
+        
+        repo.on_event("OnEventTargetLambda",
+            target=LambdaFunction(lambda_handler)
         )
     '''
 

aws_cdk/aws_ecs/__init__.py

@@ -11964,7 +11964,7 @@ class CfnTaskDefinition(
         :param placement_constraints: An array of placement constraint objects to use for tasks. .. epigraph:: This parameter isn't supported for tasks run on AWS Fargate .
         :param proxy_configuration: The configuration details for the App Mesh proxy. Your Amazon ECS container instances require at least version 1.26.0 of the container agent and at least version 1.26.0-1 of the ``ecs-init`` package to use a proxy configuration. If your container instances are launched from the Amazon ECS optimized AMI version ``20190301`` or later, they contain the required versions of the container agent and ``ecs-init`` . For more information, see `Amazon ECS-optimized Linux AMI <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
         :param requires_compatibilities: The task launch types the task definition was validated against. The valid values are ``EC2`` , ``FARGATE`` , and ``EXTERNAL`` . For more information, see `Amazon ECS launch types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
-        :param runtime_platform: The operating system that your tasks definitions run on. A platform family is specified only for tasks using the Fargate launch type. When you specify a task definition in a service, this value must match the ``runtimePlatform`` value of the service.
+        :param runtime_platform: The operating system that your tasks definitions run on. A platform family is specified only for tasks using the Fargate launch type.
         :param tags: The metadata that you apply to the task definition to help you categorize and organize them. Each tag consists of a key and an optional value. You define both of them. The following basic restrictions apply to tags: - Maximum number of tags per resource - 50 - For each resource, each tag key must be unique, and each tag key can have only one value. - Maximum key length - 128 Unicode characters in UTF-8 - Maximum value length - 256 Unicode characters in UTF-8 - If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : /
         :param task_role_arn: The short name or full Amazon Resource Name (ARN) of the AWS Identity and Access Management role that grants containers in the task permission to call AWS APIs on your behalf. For more information, see `Amazon ECS Task Role <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html>`_ in the *Amazon Elastic Container Service Developer Guide* . IAM roles for tasks on Windows require that the ``-EnableTaskIAMRole`` option is set when you launch the Amazon ECS-optimized Windows AMI. Your containers must also run some configuration code to use the feature. For more information, see `Windows IAM roles for tasks <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows_task_IAM_roles.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
         :param volumes: The list of data volume definitions for the task. For more information, see `Using data volumes in tasks <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html>`_ in the *Amazon Elastic Container Service Developer Guide* . .. epigraph:: The ``host`` and ``sourcePath`` parameters aren't supported for tasks run on AWS Fargate .
@@ -16541,7 +16541,7 @@ class CfnTaskDefinitionProps:
         :param placement_constraints: An array of placement constraint objects to use for tasks. .. epigraph:: This parameter isn't supported for tasks run on AWS Fargate .
         :param proxy_configuration: The configuration details for the App Mesh proxy. Your Amazon ECS container instances require at least version 1.26.0 of the container agent and at least version 1.26.0-1 of the ``ecs-init`` package to use a proxy configuration. If your container instances are launched from the Amazon ECS optimized AMI version ``20190301`` or later, they contain the required versions of the container agent and ``ecs-init`` . For more information, see `Amazon ECS-optimized Linux AMI <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
         :param requires_compatibilities: The task launch types the task definition was validated against. The valid values are ``EC2`` , ``FARGATE`` , and ``EXTERNAL`` . For more information, see `Amazon ECS launch types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
-        :param runtime_platform: The operating system that your tasks definitions run on. A platform family is specified only for tasks using the Fargate launch type. When you specify a task definition in a service, this value must match the ``runtimePlatform`` value of the service.
+        :param runtime_platform: The operating system that your tasks definitions run on. A platform family is specified only for tasks using the Fargate launch type.
         :param tags: The metadata that you apply to the task definition to help you categorize and organize them. Each tag consists of a key and an optional value. You define both of them. The following basic restrictions apply to tags: - Maximum number of tags per resource - 50 - For each resource, each tag key must be unique, and each tag key can have only one value. - Maximum key length - 128 Unicode characters in UTF-8 - Maximum value length - 256 Unicode characters in UTF-8 - If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : /
         :param task_role_arn: The short name or full Amazon Resource Name (ARN) of the AWS Identity and Access Management role that grants containers in the task permission to call AWS APIs on your behalf. For more information, see `Amazon ECS Task Role <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html>`_ in the *Amazon Elastic Container Service Developer Guide* . IAM roles for tasks on Windows require that the ``-EnableTaskIAMRole`` option is set when you launch the Amazon ECS-optimized Windows AMI. Your containers must also run some configuration code to use the feature. For more information, see `Windows IAM roles for tasks <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows_task_IAM_roles.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
         :param volumes: The list of data volume definitions for the task. For more information, see `Using data volumes in tasks <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html>`_ in the *Amazon Elastic Container Service Developer Guide* . .. epigraph:: The ``host`` and ``sourcePath`` parameters aren't supported for tasks run on AWS Fargate .
@@ -17052,8 +17052,6 @@ class CfnTaskDefinitionProps:
 
         A platform family is specified only for tasks using the Fargate launch type.
 
-        When you specify a task definition in a service, this value must match the ``runtimePlatform`` value of the service.
-
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecs-taskdefinition.html#cfn-ecs-taskdefinition-runtimeplatform
         '''
         result = self._values.get("runtime_platform")

aws_cdk/aws_efs/__init__.py

@@ -71,12 +71,26 @@ efs.FileSystem(self, "OneZoneFileSystem",
 ⚠️ One Zone file systems are not compatible with the MAX_IO performance mode.
 
 ⚠️ When `oneZone` is enabled, the file system is automatically placed in the first availability zone of the VPC.
-It is not currently possible to specify a different availability zone.
+To specify a different availability zone:
+
+```python
+# vpc: ec2.Vpc
+
+
+efs.FileSystem(self, "OneZoneFileSystem",
+    vpc=vpc,
+    one_zone=True,
+    vpc_subnets=ec2.SubnetSelection(
+        availability_zones=["us-east-1b"]
+    )
+)
+```
 
 ⚠️ When `oneZone` is enabled, mount targets will be created only in the specified availability zone.
 This is to prevent deployment failures due to cross-AZ configurations.
 
-⚠️ When `oneZone` is enabled, `vpcSubnets` cannot be specified.
+⚠️ When `oneZone` is enabled, `vpcSubnets` can be specified with
+`availabilityZones` that contains exactly one single zone.
 
 ### Replicating file systems
 

aws_cdk/aws_eks/__init__.py

@@ -10206,6 +10206,7 @@ class HelmChart(
         id: builtins.str,
         *,
         cluster: "ICluster",
+        atomic: typing.Optional[builtins.bool] = None,
         chart: typing.Optional[builtins.str] = None,
         chart_asset: typing.Optional[_Asset_ac2a7e61] = None,
         create_namespace: typing.Optional[builtins.bool] = None,
@@ -10222,6 +10223,7 @@ class HelmChart(
         :param scope: -
         :param id: -
         :param cluster: The EKS cluster to apply this configuration to. [disable-awslint:ref-via-interface]
+        :param atomic: Whether or not Helm should treat this operation as atomic; if set, upgrade process rolls back changes made in case of failed upgrade. The --wait flag will be set automatically if --atomic is used. Default: false
         :param chart: The name of the chart. Either this or ``chartAsset`` must be specified. Default: - No chart name. Implies ``chartAsset`` is used.
         :param chart_asset: The chart in the form of an asset. Either this or ``chart`` must be specified. Default: - No chart asset. Implies ``chart`` is used.
         :param create_namespace: create namespace if not exist. Default: true
@@ -10240,6 +10242,7 @@ class HelmChart(
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
         props = HelmChartProps(
             cluster=cluster,
+            atomic=atomic,
             chart=chart,
             chart_asset=chart_asset,
             create_namespace=create_namespace,
@@ -10261,6 +10264,11 @@ class HelmChart(
         '''The CloudFormation resource type.'''
         return typing.cast(builtins.str, jsii.sget(cls, "RESOURCE_TYPE"))
 
+    @builtins.property
+    @jsii.member(jsii_name="atomic")
+    def atomic(self) -> typing.Optional[builtins.bool]:
+        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "atomic"))
+
     @builtins.property
     @jsii.member(jsii_name="chart")
     def chart(self) -> typing.Optional[builtins.str]:
@@ -10286,6 +10294,7 @@ class HelmChart(
     jsii_type="aws-cdk-lib.aws_eks.HelmChartOptions",
     jsii_struct_bases=[],
     name_mapping={
+        "atomic": "atomic",
         "chart": "chart",
         "chart_asset": "chartAsset",
         "create_namespace": "createNamespace",
@@ -10303,6 +10312,7 @@ class HelmChartOptions:
     def __init__(
         self,
         *,
+        atomic: typing.Optional[builtins.bool] = None,
         chart: typing.Optional[builtins.str] = None,
         chart_asset: typing.Optional[_Asset_ac2a7e61] = None,
         create_namespace: typing.Optional[builtins.bool] = None,
@@ -10317,6 +10327,7 @@ class HelmChartOptions:
     ) -> None:
         '''Helm Chart options.
 
+        :param atomic: Whether or not Helm should treat this operation as atomic; if set, upgrade process rolls back changes made in case of failed upgrade. The --wait flag will be set automatically if --atomic is used. Default: false
         :param chart: The name of the chart. Either this or ``chartAsset`` must be specified. Default: - No chart name. Implies ``chartAsset`` is used.
         :param chart_asset: The chart in the form of an asset. Either this or ``chart`` must be specified. Default: - No chart asset. Implies ``chart`` is used.
         :param create_namespace: create namespace if not exist. Default: true
@@ -10347,6 +10358,7 @@ class HelmChartOptions:
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__f6972a55b9cddfcfdae45e3907a04dc773d9fa367223106572ea64bf22eafe3d)
+            check_type(argname="argument atomic", value=atomic, expected_type=type_hints["atomic"])
             check_type(argname="argument chart", value=chart, expected_type=type_hints["chart"])
             check_type(argname="argument chart_asset", value=chart_asset, expected_type=type_hints["chart_asset"])
             check_type(argname="argument create_namespace", value=create_namespace, expected_type=type_hints["create_namespace"])
@@ -10359,6 +10371,8 @@ class HelmChartOptions:
             check_type(argname="argument version", value=version, expected_type=type_hints["version"])
             check_type(argname="argument wait", value=wait, expected_type=type_hints["wait"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if atomic is not None:
+            self._values["atomic"] = atomic
         if chart is not None:
             self._values["chart"] = chart
         if chart_asset is not None:
@@ -10382,6 +10396,18 @@ class HelmChartOptions:
         if wait is not None:
             self._values["wait"] = wait
 
+    @builtins.property
+    def atomic(self) -> typing.Optional[builtins.bool]:
+        '''Whether or not Helm should treat this operation as atomic;
+
+        if set, upgrade process rolls back changes
+        made in case of failed upgrade. The --wait flag will be set automatically if --atomic is used.
+
+        :default: false
+        '''
+        result = self._values.get("atomic")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
     @builtins.property
     def chart(self) -> typing.Optional[builtins.str]:
         '''The name of the chart.
@@ -10511,6 +10537,7 @@ class HelmChartOptions:
     jsii_type="aws-cdk-lib.aws_eks.HelmChartProps",
     jsii_struct_bases=[HelmChartOptions],
     name_mapping={
+        "atomic": "atomic",
         "chart": "chart",
         "chart_asset": "chartAsset",
         "create_namespace": "createNamespace",
@@ -10529,6 +10556,7 @@ class HelmChartProps(HelmChartOptions):
     def __init__(
         self,
         *,
+        atomic: typing.Optional[builtins.bool] = None,
         chart: typing.Optional[builtins.str] = None,
         chart_asset: typing.Optional[_Asset_ac2a7e61] = None,
         create_namespace: typing.Optional[builtins.bool] = None,
@@ -10544,6 +10572,7 @@ class HelmChartProps(HelmChartOptions):
     ) -> None:
         '''Helm Chart properties.
 
+        :param atomic: Whether or not Helm should treat this operation as atomic; if set, upgrade process rolls back changes made in case of failed upgrade. The --wait flag will be set automatically if --atomic is used. Default: false
         :param chart: The name of the chart. Either this or ``chartAsset`` must be specified. Default: - No chart name. Implies ``chartAsset`` is used.
         :param chart_asset: The chart in the form of an asset. Either this or ``chart`` must be specified. Default: - No chart asset. Implies ``chart`` is used.
         :param create_namespace: create namespace if not exist. Default: true
@@ -10574,6 +10603,7 @@ class HelmChartProps(HelmChartOptions):
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__3cca1be87809b190e4c5e436f984009d3dce2043a4fb17be5ea74ad9b58debef)
+            check_type(argname="argument atomic", value=atomic, expected_type=type_hints["atomic"])
             check_type(argname="argument chart", value=chart, expected_type=type_hints["chart"])
             check_type(argname="argument chart_asset", value=chart_asset, expected_type=type_hints["chart_asset"])
             check_type(argname="argument create_namespace", value=create_namespace, expected_type=type_hints["create_namespace"])
@@ -10589,6 +10619,8 @@ class HelmChartProps(HelmChartOptions):
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "cluster": cluster,
         }
+        if atomic is not None:
+            self._values["atomic"] = atomic
         if chart is not None:
             self._values["chart"] = chart
         if chart_asset is not None:
@@ -10612,6 +10644,18 @@ class HelmChartProps(HelmChartOptions):
         if wait is not None:
             self._values["wait"] = wait
 
+    @builtins.property
+    def atomic(self) -> typing.Optional[builtins.bool]:
+        '''Whether or not Helm should treat this operation as atomic;
+
+        if set, upgrade process rolls back changes
+        made in case of failed upgrade. The --wait flag will be set automatically if --atomic is used.
+
+        :default: false
+        '''
+        result = self._values.get("atomic")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
     @builtins.property
     def chart(self) -> typing.Optional[builtins.str]:
         '''The name of the chart.
@@ -10986,6 +11030,7 @@ class ICluster(_IResource_c80c4260, _IConnectable_10015a05, typing_extensions.Pr
         self,
         id: builtins.str,
         *,
+        atomic: typing.Optional[builtins.bool] = None,
         chart: typing.Optional[builtins.str] = None,
         chart_asset: typing.Optional[_Asset_ac2a7e61] = None,
         create_namespace: typing.Optional[builtins.bool] = None,
@@ -11001,6 +11046,7 @@ class ICluster(_IResource_c80c4260, _IConnectable_10015a05, typing_extensions.Pr
         '''Defines a Helm chart in this cluster.
 
         :param id: logical id of this chart.
+        :param atomic: Whether or not Helm should treat this operation as atomic; if set, upgrade process rolls back changes made in case of failed upgrade. The --wait flag will be set automatically if --atomic is used. Default: false
         :param chart: The name of the chart. Either this or ``chartAsset`` must be specified. Default: - No chart name. Implies ``chartAsset`` is used.
         :param chart_asset: The chart in the form of an asset. Either this or ``chart`` must be specified. Default: - No chart asset. Implies ``chart`` is used.
         :param create_namespace: create namespace if not exist. Default: true
@@ -11346,6 +11392,7 @@ class _IClusterProxy(
         self,
         id: builtins.str,
         *,
+        atomic: typing.Optional[builtins.bool] = None,
         chart: typing.Optional[builtins.str] = None,
         chart_asset: typing.Optional[_Asset_ac2a7e61] = None,
         create_namespace: typing.Optional[builtins.bool] = None,
@@ -11361,6 +11408,7 @@ class _IClusterProxy(
         '''Defines a Helm chart in this cluster.
 
         :param id: logical id of this chart.
+        :param atomic: Whether or not Helm should treat this operation as atomic; if set, upgrade process rolls back changes made in case of failed upgrade. The --wait flag will be set automatically if --atomic is used. Default: false
         :param chart: The name of the chart. Either this or ``chartAsset`` must be specified. Default: - No chart name. Implies ``chartAsset`` is used.
         :param chart_asset: The chart in the form of an asset. Either this or ``chart`` must be specified. Default: - No chart asset. Implies ``chart`` is used.
         :param create_namespace: create namespace if not exist. Default: true
@@ -11379,6 +11427,7 @@ class _IClusterProxy(
             type_hints = typing.get_type_hints(_typecheckingstub__08729ac4099dd779679b753fc203b6492daf687a1f8a07194d707cc6e3650d37)
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
         options = HelmChartOptions(
+            atomic=atomic,
             chart=chart,
             chart_asset=chart_asset,
             create_namespace=create_namespace,
@@ -15450,6 +15499,7 @@ class Cluster(
         self,
         id: builtins.str,
         *,
+        atomic: typing.Optional[builtins.bool] = None,
         chart: typing.Optional[builtins.str] = None,
         chart_asset: typing.Optional[_Asset_ac2a7e61] = None,
         create_namespace: typing.Optional[builtins.bool] = None,
@@ -15465,6 +15515,7 @@ class Cluster(
         '''Defines a Helm chart in this cluster.
 
         :param id: logical id of this chart.
+        :param atomic: Whether or not Helm should treat this operation as atomic; if set, upgrade process rolls back changes made in case of failed upgrade. The --wait flag will be set automatically if --atomic is used. Default: false
         :param chart: The name of the chart. Either this or ``chartAsset`` must be specified. Default: - No chart name. Implies ``chartAsset`` is used.
         :param chart_asset: The chart in the form of an asset. Either this or ``chart`` must be specified. Default: - No chart asset. Implies ``chart`` is used.
         :param create_namespace: create namespace if not exist. Default: true
@@ -15483,6 +15534,7 @@ class Cluster(
             type_hints = typing.get_type_hints(_typecheckingstub__ff2724c18a4ac2eb51d401c5ea14857dd81b51b7f44f46a894e6cac37edd774f)
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
         options = HelmChartOptions(
+            atomic=atomic,
             chart=chart,
             chart_asset=chart_asset,
             create_namespace=create_namespace,
@@ -19047,6 +19099,7 @@ def _typecheckingstub__52726bf866c12e59b4b3f451037674503c3d95da4a298075df121981e
     id: builtins.str,
     *,
     cluster: ICluster,
+    atomic: typing.Optional[builtins.bool] = None,
     chart: typing.Optional[builtins.str] = None,
     chart_asset: typing.Optional[_Asset_ac2a7e61] = None,
     create_namespace: typing.Optional[builtins.bool] = None,
@@ -19064,6 +19117,7 @@ def _typecheckingstub__52726bf866c12e59b4b3f451037674503c3d95da4a298075df121981e
 
 def _typecheckingstub__f6972a55b9cddfcfdae45e3907a04dc773d9fa367223106572ea64bf22eafe3d(
     *,
+    atomic: typing.Optional[builtins.bool] = None,
     chart: typing.Optional[builtins.str] = None,
     chart_asset: typing.Optional[_Asset_ac2a7e61] = None,
     create_namespace: typing.Optional[builtins.bool] = None,
@@ -19081,6 +19135,7 @@ def _typecheckingstub__f6972a55b9cddfcfdae45e3907a04dc773d9fa367223106572ea64bf2
 
 def _typecheckingstub__3cca1be87809b190e4c5e436f984009d3dce2043a4fb17be5ea74ad9b58debef(
     *,
+    atomic: typing.Optional[builtins.bool] = None,
     chart: typing.Optional[builtins.str] = None,
     chart_asset: typing.Optional[_Asset_ac2a7e61] = None,
     create_namespace: typing.Optional[builtins.bool] = None,
@@ -19112,6 +19167,7 @@ def _typecheckingstub__027a1f8770d590b40eccba041afe2250c0b1eab8a8d7e20ca1928a01a
 def _typecheckingstub__08729ac4099dd779679b753fc203b6492daf687a1f8a07194d707cc6e3650d37(
     id: builtins.str,
     *,
+    atomic: typing.Optional[builtins.bool] = None,
     chart: typing.Optional[builtins.str] = None,
     chart_asset: typing.Optional[_Asset_ac2a7e61] = None,
     create_namespace: typing.Optional[builtins.bool] = None,
@@ -19613,6 +19669,7 @@ def _typecheckingstub__a6aa2e382a694744786e7d6854ca13bd607970f73536c975ae7475325
 def _typecheckingstub__ff2724c18a4ac2eb51d401c5ea14857dd81b51b7f44f46a894e6cac37edd774f(
     id: builtins.str,
     *,
+    atomic: typing.Optional[builtins.bool] = None,
     chart: typing.Optional[builtins.str] = None,
     chart_asset: typing.Optional[_Asset_ac2a7e61] = None,
     create_namespace: typing.Optional[builtins.bool] = None,

aws_cdk/aws_entityresolution/__init__.py

@@ -2912,7 +2912,7 @@ class CfnPolicyStatement(
         :param statement_id: A statement identifier that differentiates the statement from others in the same policy.
         :param action: The action that the principal can use on the resource. For example, ``entityresolution:GetIdMappingJob`` , ``entityresolution:GetMatchingJob`` .
         :param condition: A set of condition keys that you can use in key policies.
-        :param effect: Determines whether the permissions specified in the policy are to be allowed ( ``Allow`` ) or denied ( ``Deny`` ).
+        :param effect: Determines whether the permissions specified in the policy are to be allowed ( ``Allow`` ) or denied ( ``Deny`` ). .. epigraph:: If you set the value of the ``effect`` parameter to ``Deny`` for the ``AddPolicyStatement`` operation, you must also set the value of the ``effect`` parameter in the ``policy`` to ``Deny`` for the ``PutPolicy`` operation.
         :param principal: The AWS service or AWS account that can access the resource defined as ARN.
         '''
         if __debug__:
@@ -3073,7 +3073,7 @@ class CfnPolicyStatementProps:
         :param statement_id: A statement identifier that differentiates the statement from others in the same policy.
         :param action: The action that the principal can use on the resource. For example, ``entityresolution:GetIdMappingJob`` , ``entityresolution:GetMatchingJob`` .
         :param condition: A set of condition keys that you can use in key policies.
-        :param effect: Determines whether the permissions specified in the policy are to be allowed ( ``Allow`` ) or denied ( ``Deny`` ).
+        :param effect: Determines whether the permissions specified in the policy are to be allowed ( ``Allow`` ) or denied ( ``Deny`` ). .. epigraph:: If you set the value of the ``effect`` parameter to ``Deny`` for the ``AddPolicyStatement`` operation, you must also set the value of the ``effect`` parameter in the ``policy`` to ``Deny`` for the ``PutPolicy`` operation.
         :param principal: The AWS service or AWS account that can access the resource defined as ARN.
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-entityresolution-policystatement.html
@@ -3161,6 +3161,10 @@ class CfnPolicyStatementProps:
     def effect(self) -> typing.Optional[builtins.str]:
         '''Determines whether the permissions specified in the policy are to be allowed ( ``Allow`` ) or denied ( ``Deny`` ).
 
+        .. epigraph::
+
+           If you set the value of the ``effect`` parameter to ``Deny`` for the ``AddPolicyStatement`` operation, you must also set the value of the ``effect`` parameter in the ``policy`` to ``Deny`` for the ``PutPolicy`` operation.
+
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-entityresolution-policystatement.html#cfn-entityresolution-policystatement-effect
         '''
         result = self._values.get("effect")

aws_cdk/aws_events/__init__.py

@@ -289,6 +289,75 @@ from ..aws_iam import (
 )
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_events.ApiDestinationAttributes",
+    jsii_struct_bases=[],
+    name_mapping={
+        "api_destination_arn": "apiDestinationArn",
+        "connection": "connection",
+    },
+)
+class ApiDestinationAttributes:
+    def __init__(
+        self,
+        *,
+        api_destination_arn: builtins.str,
+        connection: "IConnection",
+    ) -> None:
+        '''The properties to import an existing Api Destination.
+
+        :param api_destination_arn: The ARN of the Api Destination.
+        :param connection: The Connection to associate with the Api Destination.
+
+        :exampleMetadata: infused
+
+        Example::
+
+            connection = events.Connection.from_event_bus_arn(self, "Connection", "arn:aws:events:us-east-1:123456789012:event-bus/EventBusName", "arn:aws:secretsmanager:us-east-1:123456789012:secret:SecretName-f3gDy9")
+            
+            api_destination_arn = "arn:aws:events:us-east-1:123456789012:api-destination/DestinationName"
+            destination = events.ApiDestination.from_api_destination_attributes(self, "Destination", api_destination_arn=api_destination_arn, connection=connection)
+            
+            rule = events.Rule(self, "OtherRule",
+                schedule=events.Schedule.rate(Duration.minutes(10)),
+                targets=[targets.ApiDestination(destination)]
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__803612bfb0a8da2a8e0ca427792d066e933032d6f722156869f61949617c8303)
+            check_type(argname="argument api_destination_arn", value=api_destination_arn, expected_type=type_hints["api_destination_arn"])
+            check_type(argname="argument connection", value=connection, expected_type=type_hints["connection"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "api_destination_arn": api_destination_arn,
+            "connection": connection,
+        }
+
+    @builtins.property
+    def api_destination_arn(self) -> builtins.str:
+        '''The ARN of the Api Destination.'''
+        result = self._values.get("api_destination_arn")
+        assert result is not None, "Required property 'api_destination_arn' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def connection(self) -> "IConnection":
+        '''The Connection to associate with the Api Destination.'''
+        result = self._values.get("connection")
+        assert result is not None, "Required property 'connection' is missing"
+        return typing.cast("IConnection", 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 "ApiDestinationAttributes(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_events.ApiDestinationProps",
     jsii_struct_bases=[],
@@ -10706,6 +10775,33 @@ class ApiDestination(
 
         jsii.create(self.__class__, self, [scope, id, props])
 
+    @jsii.member(jsii_name="fromApiDestinationAttributes")
+    @builtins.classmethod
+    def from_api_destination_attributes(
+        cls,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        api_destination_arn: builtins.str,
+        connection: IConnection,
+    ) -> "ApiDestination":
+        '''Create an Api Destination construct from an existing Api Destination ARN.
+
+        :param scope: The scope creating construct (usually ``this``).
+        :param id: The construct's id.
+        :param api_destination_arn: The ARN of the Api Destination.
+        :param connection: The Connection to associate with the Api Destination.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__e49376311071a64effa3b8c1dd1bd3ee0e1b2ef0514b800dd0053110fa18cb55)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        attrs = ApiDestinationAttributes(
+            api_destination_arn=api_destination_arn, connection=connection
+        )
+
+        return typing.cast("ApiDestination", jsii.sinvoke(cls, "fromApiDestinationAttributes", [scope, id, attrs]))
+
     @builtins.property
     @jsii.member(jsii_name="apiDestinationArn")
     def api_destination_arn(self) -> builtins.str:
@@ -11243,6 +11339,7 @@ class EventBus(
 
 __all__ = [
     "ApiDestination",
+    "ApiDestinationAttributes",
     "ApiDestinationProps",
     "Archive",
     "ArchiveProps",
@@ -11294,6 +11391,14 @@ __all__ = [
 
 publication.publish()
 
+def _typecheckingstub__803612bfb0a8da2a8e0ca427792d066e933032d6f722156869f61949617c8303(
+    *,
+    api_destination_arn: builtins.str,
+    connection: IConnection,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__ce93e81ddac7a0ebc3fe6cf2783ea61dde8338f099332864ff087db25f7e83f2(
     *,
     connection: IConnection,
@@ -12562,6 +12667,16 @@ def _typecheckingstub__1aa3407b00276436e9ed372bbdc08c6dfd1419e8730d4851ceddeade8
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__e49376311071a64effa3b8c1dd1bd3ee0e1b2ef0514b800dd0053110fa18cb55(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    api_destination_arn: builtins.str,
+    connection: IConnection,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__3e9e21c5f043688b8d785343f3fca5b1c769d309ab6d381af52c9421aebc588a(
     *,
     event_pattern: typing.Union[EventPattern, typing.Dict[builtins.str, typing.Any]],

aws_cdk/aws_events_targets/__init__.py

@@ -347,6 +347,21 @@ rule = events.Rule(self, "Rule",
 )
 ```
 
+You can also import an existing connection and destination
+to create additional rules:
+
+```python
+connection = events.Connection.from_event_bus_arn(self, "Connection", "arn:aws:events:us-east-1:123456789012:event-bus/EventBusName", "arn:aws:secretsmanager:us-east-1:123456789012:secret:SecretName-f3gDy9")
+
+api_destination_arn = "arn:aws:events:us-east-1:123456789012:api-destination/DestinationName"
+destination = events.ApiDestination.from_api_destination_attributes(self, "Destination", api_destination_arn=api_destination_arn, connection=connection)
+
+rule = events.Rule(self, "OtherRule",
+    schedule=events.Schedule.rate(Duration.minutes(10)),
+    targets=[targets.ApiDestination(destination)]
+)
+```
+
 ## Put an event on an EventBridge bus
 
 Use the `EventBus` target to route event to a different EventBus.

aws_cdk/aws_fis/__init__.py

@@ -220,7 +220,8 @@ class CfnExperimentTemplate(
     @builtins.property
     @jsii.member(jsii_name="attrId")
     def attr_id(self) -> builtins.str:
-        '''
+        '''The ID of the experiment template.
+
         :cloudformationAttribute: Id
         '''
         return typing.cast(builtins.str, jsii.get(self, "attrId"))