aws-cdk-lib 2.172.0__py3-none-any.whl → 2.173.1__py3-none-any.whl

aws_cdk/aws_route53_targets/__init__.py

@@ -5,88 +5,103 @@ This library contains Route53 Alias Record targets for:
 
 * API Gateway custom domains
 
-  ```python
-  import aws_cdk.aws_apigateway as apigw
+```python
+import aws_cdk.aws_apigateway as apigw
+
+# zone: route53.HostedZone
+# rest_api: apigw.LambdaRestApi
 
-  # zone: route53.HostedZone
-  # rest_api: apigw.LambdaRestApi
 
+route53.ARecord(self, "AliasRecord",
+    zone=zone,
+    target=route53.RecordTarget.from_alias(targets.ApiGateway(rest_api))
+)
+```
 
-  route53.ARecord(self, "AliasRecord",
-      zone=zone,
-      target=route53.RecordTarget.from_alias(targets.ApiGateway(rest_api))
-  )
-  ```
 * API Gateway V2 custom domains
 
-  ```python
-  import aws_cdk.aws_apigatewayv2 as apigwv2
+```python
+import aws_cdk.aws_apigatewayv2 as apigwv2
 
-  # zone: route53.HostedZone
-  # domain_name: apigwv2.DomainName
+# zone: route53.HostedZone
+# domain_name: apigwv2.DomainName
 
 
-  route53.ARecord(self, "AliasRecord",
-      zone=zone,
-      target=route53.RecordTarget.from_alias(targets.ApiGatewayv2DomainProperties(domain_name.regional_domain_name, domain_name.regional_hosted_zone_id))
-  )
-  ```
+route53.ARecord(self, "AliasRecord",
+    zone=zone,
+    target=route53.RecordTarget.from_alias(targets.ApiGatewayv2DomainProperties(domain_name.regional_domain_name, domain_name.regional_hosted_zone_id))
+)
+```
+
 * AppSync custom domains
 
-  ```python
-  import aws_cdk.aws_appsync as appsync
+```python
+import aws_cdk.aws_appsync as appsync
+
+# zone: route53.HostedZone
+# graphql_api: appsync.GraphqlApi
 
-  # zone: route53.HostedZone
-  # graphql_api: appsync.GraphqlApi
 
+route53.ARecord(self, "AliasRecord",
+    zone=zone,
+    target=route53.RecordTarget.from_alias(targets.AppSyncTarget(graphql_api))
+)
+```
 
-  route53.ARecord(self, "AliasRecord",
-      zone=zone,
-      target=route53.RecordTarget.from_alias(targets.AppSyncTarget(graphql_api))
-  )
-  ```
 * CloudFront distributions
 
-  ```python
-  import aws_cdk.aws_cloudfront as cloudfront
+```python
+import aws_cdk.aws_cloudfront as cloudfront
 
-  # zone: route53.HostedZone
-  # distribution: cloudfront.CloudFrontWebDistribution
+# zone: route53.HostedZone
+# distribution: cloudfront.CloudFrontWebDistribution
 
 
-  route53.ARecord(self, "AliasRecord",
-      zone=zone,
-      target=route53.RecordTarget.from_alias(targets.CloudFrontTarget(distribution))
-  )
-  ```
+route53.ARecord(self, "AliasRecord",
+    zone=zone,
+    target=route53.RecordTarget.from_alias(targets.CloudFrontTarget(distribution))
+)
+```
+
 * ELBv2 load balancers
 
-  ```python
-  import aws_cdk.aws_elasticloadbalancingv2 as elbv2
+By providing optional properties, you can specify whether to evaluate target health.
+
+```python
+import aws_cdk.aws_elasticloadbalancingv2 as elbv2
+
+# zone: route53.HostedZone
+# lb: elbv2.ApplicationLoadBalancer
 
-  # zone: route53.HostedZone
-  # lb: elbv2.ApplicationLoadBalancer
 
+route53.ARecord(self, "AliasRecord",
+    zone=zone,
+    target=route53.RecordTarget.from_alias(
+        targets.LoadBalancerTarget(lb, {
+            "evaluate_target_health": True
+        }))
+)
+```
 
-  route53.ARecord(self, "AliasRecord",
-      zone=zone,
-      target=route53.RecordTarget.from_alias(targets.LoadBalancerTarget(lb))
-  )
-  ```
 * Classic load balancers
 
-  ```python
-  import aws_cdk.aws_elasticloadbalancing as elb
+By providing optional properties, you can specify whether to evaluate target health.
+
+```python
+import aws_cdk.aws_elasticloadbalancing as elb
 
-  # zone: route53.HostedZone
-  # lb: elb.LoadBalancer
+# zone: route53.HostedZone
+# lb: elb.LoadBalancer
 
 
-  route53.ARecord(self, "AliasRecord",
-      zone=zone,
-      target=route53.RecordTarget.from_alias(targets.ClassicLoadBalancerTarget(lb))
-  )
-  ```
+route53.ARecord(self, "AliasRecord",
+    zone=zone,
+    target=route53.RecordTarget.from_alias(
+        targets.ClassicLoadBalancerTarget(lb, {
+            "evaluate_target_health": True
+        }))
+)
+```
 
 **Important:** Based on [AWS documentation](https://aws.amazon.com/de/premiumsupport/knowledge-center/alias-resource-record-set-route53-cli/), all alias record in Route 53 that points to a Elastic Load Balancer will always include *dualstack* for the DNSName to resolve IPv4/IPv6 addresses (without *dualstack* IPv6 will not resolve).
 
@@ -94,18 +109,23 @@ For example, if the Amazon-provided DNS for the load balancer is `ALB-xxxxxxx.us
 
 * GlobalAccelerator
 
-  ```python
-  import aws_cdk.aws_globalaccelerator as globalaccelerator
+By providing optional properties, you can specify whether to evaluate target health.
 
-  # zone: route53.HostedZone
-  # accelerator: globalaccelerator.Accelerator
+```python
+import aws_cdk.aws_globalaccelerator as globalaccelerator
 
+# zone: route53.HostedZone
+# accelerator: globalaccelerator.Accelerator
 
-  route53.ARecord(self, "AliasRecord",
-      zone=zone,
-      target=route53.RecordTarget.from_alias(targets.GlobalAcceleratorTarget(accelerator))
-  )
-  ```
+
+route53.ARecord(self, "AliasRecord",
+    zone=zone,
+    target=route53.RecordTarget.from_alias(
+        targets.GlobalAcceleratorTarget(accelerator, {
+            "evaluate_target_health": True
+        }))
+)
+```
 
 **Important:** If you use GlobalAcceleratorDomainTarget, passing a string rather than an instance of IAccelerator, ensure that the string is a valid domain name of an existing Global Accelerator instance.
 See [the documentation on DNS addressing](https://docs.aws.amazon.com/global-accelerator/latest/dg/dns-addressing-custom-domains.dns-addressing.html) with Global Accelerator for more info.
@@ -132,6 +152,8 @@ route53.ARecord(self, "AliasRecord",
 **Important:** The Bucket name must strictly match the full DNS name.
 See [the Developer Guide](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/getting-started.html) for more info.
 
+By providing optional properties, you can specify whether to evaluate target health.
+
 ```python
 import aws_cdk.aws_s3 as s3
 
@@ -150,38 +172,45 @@ zone = route53.HostedZone.from_lookup(self, "Zone", domain_name=domain_name) # e
 route53.ARecord(self, "AliasRecord",
     zone=zone,
     record_name=record_name,  # www
-    target=route53.RecordTarget.from_alias(targets.BucketWebsiteTarget(bucket_website))
+    target=route53.RecordTarget.from_alias(
+        targets.BucketWebsiteTarget(bucket_website, {
+            "evaluate_target_health": True
+        }))
 )
 ```
 
 * User pool domain
 
-  ```python
-  import aws_cdk.aws_cognito as cognito
+```python
+import aws_cdk.aws_cognito as cognito
+
+# zone: route53.HostedZone
+# domain: cognito.UserPoolDomain
 
-  # zone: route53.HostedZone
-  # domain: cognito.UserPoolDomain
+route53.ARecord(self, "AliasRecord",
+    zone=zone,
+    target=route53.RecordTarget.from_alias(targets.UserPoolDomainTarget(domain))
+)
+```
 
-  route53.ARecord(self, "AliasRecord",
-      zone=zone,
-      target=route53.RecordTarget.from_alias(targets.UserPoolDomainTarget(domain))
-  )
-  ```
 * Route 53 record
 
-  ```python
-  # zone: route53.HostedZone
-  # record: route53.ARecord
+```python
+# zone: route53.HostedZone
+# record: route53.ARecord
+
+route53.ARecord(self, "AliasRecord",
+    zone=zone,
+    target=route53.RecordTarget.from_alias(targets.Route53RecordTarget(record))
+)
+```
 
-  route53.ARecord(self, "AliasRecord",
-      zone=zone,
-      target=route53.RecordTarget.from_alias(targets.Route53RecordTarget(record))
-  )
-  ```
 * Elastic Beanstalk environment:
 
 **Important:** Only supports Elastic Beanstalk environments created after 2016 that have a regional endpoint.
 
+By providing optional properties, you can specify whether to evaluate target health.
+
 ```python
 # zone: route53.HostedZone
 # ebs_environment_url: str
@@ -189,7 +218,10 @@ route53.ARecord(self, "AliasRecord",
 
 route53.ARecord(self, "AliasRecord",
     zone=zone,
-    target=route53.RecordTarget.from_alias(targets.ElasticBeanstalkEnvironmentEndpointTarget(ebs_environment_url))
+    target=route53.RecordTarget.from_alias(
+        targets.ElasticBeanstalkEnvironmentEndpointTarget(ebs_environment_url, {
+            "evaluate_target_health": True
+        }))
 )
 ```
 
@@ -438,18 +470,27 @@ class BucketWebsiteTarget(
         route53.ARecord(self, "AliasRecord",
             zone=zone,
             record_name=record_name,  # www
-            target=route53.RecordTarget.from_alias(targets.BucketWebsiteTarget(bucket_website))
+            target=route53.RecordTarget.from_alias(
+                targets.BucketWebsiteTarget(bucket_website, {
+                    "evaluate_target_health": True
+                }))
         )
     '''
 
-    def __init__(self, bucket: _IBucket_42e086fd) -> None:
+    def __init__(
+        self,
+        bucket: _IBucket_42e086fd,
+        props: typing.Optional["IAliasRecordTargetProps"] = None,
+    ) -> None:
         '''
         :param bucket: -
+        :param props: -
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__ddbd19de44d0f648d972f99cbd261ae3e9159511037db7c12ae0ebcb70553020)
             check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
-        jsii.create(self.__class__, self, [bucket])
+            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
+        jsii.create(self.__class__, self, [bucket, props])
 
     @jsii.member(jsii_name="bind")
     def bind(
@@ -488,18 +529,27 @@ class ClassicLoadBalancerTarget(
         
         route53.ARecord(self, "AliasRecord",
             zone=zone,
-            target=route53.RecordTarget.from_alias(targets.ClassicLoadBalancerTarget(lb))
+            target=route53.RecordTarget.from_alias(
+                targets.ClassicLoadBalancerTarget(lb, {
+                    "evaluate_target_health": True
+                }))
         )
     '''
 
-    def __init__(self, load_balancer: _LoadBalancer_a894d40e) -> None:
+    def __init__(
+        self,
+        load_balancer: _LoadBalancer_a894d40e,
+        props: typing.Optional["IAliasRecordTargetProps"] = None,
+    ) -> None:
         '''
         :param load_balancer: -
+        :param props: -
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__df60d89e015cd817a27383507bd36a21baad91e6194326c62959170a57cfec93)
             check_type(argname="argument load_balancer", value=load_balancer, expected_type=type_hints["load_balancer"])
-        jsii.create(self.__class__, self, [load_balancer])
+            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
+        jsii.create(self.__class__, self, [load_balancer, props])
 
     @jsii.member(jsii_name="bind")
     def bind(
@@ -608,18 +658,27 @@ class ElasticBeanstalkEnvironmentEndpointTarget(
         
         route53.ARecord(self, "AliasRecord",
             zone=zone,
-            target=route53.RecordTarget.from_alias(targets.ElasticBeanstalkEnvironmentEndpointTarget(ebs_environment_url))
+            target=route53.RecordTarget.from_alias(
+                targets.ElasticBeanstalkEnvironmentEndpointTarget(ebs_environment_url, {
+                    "evaluate_target_health": True
+                }))
         )
     '''
 
-    def __init__(self, environment_endpoint: builtins.str) -> None:
+    def __init__(
+        self,
+        environment_endpoint: builtins.str,
+        props: typing.Optional["IAliasRecordTargetProps"] = None,
+    ) -> None:
         '''
         :param environment_endpoint: -
+        :param props: -
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__8d25d707c026f750072f9d979b0260dab154996d630c701cc92fda7ebe39de84)
             check_type(argname="argument environment_endpoint", value=environment_endpoint, expected_type=type_hints["environment_endpoint"])
-        jsii.create(self.__class__, self, [environment_endpoint])
+            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
+        jsii.create(self.__class__, self, [environment_endpoint, props])
 
     @jsii.member(jsii_name="bind")
     def bind(
@@ -654,18 +713,26 @@ class GlobalAcceleratorDomainTarget(
         # The values are placeholders you should change.
         from aws_cdk import aws_route53_targets as route53_targets
         
-        global_accelerator_domain_target = route53_targets.GlobalAcceleratorDomainTarget("acceleratorDomainName")
+        # alias_record_target_props: route53_targets.IAliasRecordTargetProps
+        
+        global_accelerator_domain_target = route53_targets.GlobalAcceleratorDomainTarget("acceleratorDomainName", alias_record_target_props)
     '''
 
-    def __init__(self, accelerator_domain_name: builtins.str) -> None:
+    def __init__(
+        self,
+        accelerator_domain_name: builtins.str,
+        props: typing.Optional["IAliasRecordTargetProps"] = None,
+    ) -> None:
         '''Create an Alias Target for a Global Accelerator domain name.
 
         :param accelerator_domain_name: -
+        :param props: -
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__2c1f5b78bdd86e72483e6033d5bd58f9ee505b8c5c7e7f7a4716fcd03bd2f17e)
             check_type(argname="argument accelerator_domain_name", value=accelerator_domain_name, expected_type=type_hints["accelerator_domain_name"])
-        jsii.create(self.__class__, self, [accelerator_domain_name])
+            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
+        jsii.create(self.__class__, self, [accelerator_domain_name, props])
 
     @jsii.member(jsii_name="bind")
     def bind(
@@ -714,19 +781,60 @@ class GlobalAcceleratorTarget(
         
         route53.ARecord(self, "AliasRecord",
             zone=zone,
-            target=route53.RecordTarget.from_alias(targets.GlobalAcceleratorTarget(accelerator))
+            target=route53.RecordTarget.from_alias(
+                targets.GlobalAcceleratorTarget(accelerator, {
+                    "evaluate_target_health": True
+                }))
         )
     '''
 
-    def __init__(self, accelerator: _IAccelerator_88df59f2) -> None:
+    def __init__(
+        self,
+        accelerator: _IAccelerator_88df59f2,
+        props: typing.Optional["IAliasRecordTargetProps"] = None,
+    ) -> None:
         '''Create an Alias Target for a Global Accelerator instance.
 
         :param accelerator: -
+        :param props: -
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__6e91db2b16be80023a03d4863b5100b3072db6e16f816be05e613cdcc1e6baec)
             check_type(argname="argument accelerator", value=accelerator, expected_type=type_hints["accelerator"])
-        jsii.create(self.__class__, self, [accelerator])
+            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
+        jsii.create(self.__class__, self, [accelerator, props])
+
+
+@jsii.interface(jsii_type="aws-cdk-lib.aws_route53_targets.IAliasRecordTargetProps")
+class IAliasRecordTargetProps(typing_extensions.Protocol):
+    '''Properties the alias record target.'''
+
+    @builtins.property
+    @jsii.member(jsii_name="evaluateTargetHealth")
+    def evaluate_target_health(self) -> typing.Optional[builtins.bool]:
+        '''Evaluate target health.
+
+        :default: - no health check configuration
+        '''
+        ...
+
+
+class _IAliasRecordTargetPropsProxy:
+    '''Properties the alias record target.'''
+
+    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_route53_targets.IAliasRecordTargetProps"
+
+    @builtins.property
+    @jsii.member(jsii_name="evaluateTargetHealth")
+    def evaluate_target_health(self) -> typing.Optional[builtins.bool]:
+        '''Evaluate target health.
+
+        :default: - no health check configuration
+        '''
+        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "evaluateTargetHealth"))
+
+# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
+typing.cast(typing.Any, IAliasRecordTargetProps).__jsii_proxy_class__ = lambda : _IAliasRecordTargetPropsProxy
 
 
 @jsii.implements(_IAliasRecordTarget_aae9327f)
@@ -798,18 +906,27 @@ class LoadBalancerTarget(
         
         route53.ARecord(self, "AliasRecord",
             zone=zone,
-            target=route53.RecordTarget.from_alias(targets.LoadBalancerTarget(lb))
+            target=route53.RecordTarget.from_alias(
+                targets.LoadBalancerTarget(lb, {
+                    "evaluate_target_health": True
+                }))
         )
     '''
 
-    def __init__(self, load_balancer: _ILoadBalancerV2_4c5c0fbb) -> None:
+    def __init__(
+        self,
+        load_balancer: _ILoadBalancerV2_4c5c0fbb,
+        props: typing.Optional[IAliasRecordTargetProps] = None,
+    ) -> None:
         '''
         :param load_balancer: -
+        :param props: -
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__d1a985c9395ef813e5bd41f719bb6218efa5bb0e851f54f91b3d61c932cb1c59)
             check_type(argname="argument load_balancer", value=load_balancer, expected_type=type_hints["load_balancer"])
-        jsii.create(self.__class__, self, [load_balancer])
+            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
+        jsii.create(self.__class__, self, [load_balancer, props])
 
     @jsii.member(jsii_name="bind")
     def bind(
@@ -973,6 +1090,7 @@ __all__ = [
     "ElasticBeanstalkEnvironmentEndpointTarget",
     "GlobalAcceleratorDomainTarget",
     "GlobalAcceleratorTarget",
+    "IAliasRecordTargetProps",
     "InterfaceVpcEndpointTarget",
     "LoadBalancerTarget",
     "Route53RecordTarget",
@@ -1023,6 +1141,7 @@ def _typecheckingstub__bb6c1847e1d1aaadc5cdfa732af7d95f520ae163215b4adf60347fc2c
 
 def _typecheckingstub__ddbd19de44d0f648d972f99cbd261ae3e9159511037db7c12ae0ebcb70553020(
     bucket: _IBucket_42e086fd,
+    props: typing.Optional[IAliasRecordTargetProps] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -1036,6 +1155,7 @@ def _typecheckingstub__dd2ecb9daaec6458d815966f81355d94c2b67af66e5e1242ed3eb8004
 
 def _typecheckingstub__df60d89e015cd817a27383507bd36a21baad91e6194326c62959170a57cfec93(
     load_balancer: _LoadBalancer_a894d40e,
+    props: typing.Optional[IAliasRecordTargetProps] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -1068,6 +1188,7 @@ def _typecheckingstub__ff9f8a6340ffc435ad18afba28ab7e6b035f0745841d574ed011feee8
 
 def _typecheckingstub__8d25d707c026f750072f9d979b0260dab154996d630c701cc92fda7ebe39de84(
     environment_endpoint: builtins.str,
+    props: typing.Optional[IAliasRecordTargetProps] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -1081,6 +1202,7 @@ def _typecheckingstub__84020a15dd8ef0dcc21b591bd97f450f84cc046c2f1899e6aab8e6cbf
 
 def _typecheckingstub__2c1f5b78bdd86e72483e6033d5bd58f9ee505b8c5c7e7f7a4716fcd03bd2f17e(
     accelerator_domain_name: builtins.str,
+    props: typing.Optional[IAliasRecordTargetProps] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -1094,6 +1216,7 @@ def _typecheckingstub__558f27329c2636934fcd56512940ef2784d615ef258b5e13b88e1bdfd
 
 def _typecheckingstub__6e91db2b16be80023a03d4863b5100b3072db6e16f816be05e613cdcc1e6baec(
     accelerator: _IAccelerator_88df59f2,
+    props: typing.Optional[IAliasRecordTargetProps] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -1113,6 +1236,7 @@ def _typecheckingstub__d6092dd3b5ac5bc3015dda9338cbe628b55da24a7ed91f812d3cfd949
 
 def _typecheckingstub__d1a985c9395ef813e5bd41f719bb6218efa5bb0e851f54f91b3d61c932cb1c59(
     load_balancer: _ILoadBalancerV2_4c5c0fbb,
+    props: typing.Optional[IAliasRecordTargetProps] = None,
 ) -> None:
     """Type checking stubs"""
     pass

aws_cdk/aws_route53resolver/__init__.py

@@ -713,7 +713,7 @@ class CfnFirewallRuleGroup(
         ) -> None:
             '''A single firewall rule in a rule group.
 
-            :param action: The action that DNS Firewall should take on a DNS query when it matches one of the domains in the rule's domain list: - ``ALLOW`` - Permit the request to go through. - ``ALERT`` - Permit the request to go through but send an alert to the logs. - ``BLOCK`` - Disallow the request. If this is specified,then ``BlockResponse`` must also be specified. if ``BlockResponse`` is ``OVERRIDE`` , then all of the following ``OVERRIDE`` attributes must be specified: - ``BlockOverrideDnsType`` - ``BlockOverrideDomain`` - ``BlockOverrideTtl``
+            :param action: The action that DNS Firewall should take on a DNS query when it matches one of the domains in the rule's domain list, or a threat in a DNS Firewall Advvanced rule: - ``ALLOW`` - Permit the request to go through. Not available for DNS Firewall Advanced rules. - ``ALERT`` - Permit the request to go through but send an alert to the logs. - ``BLOCK`` - Disallow the request. If this is specified,then ``BlockResponse`` must also be specified. if ``BlockResponse`` is ``OVERRIDE`` , then all of the following ``OVERRIDE`` attributes must be specified: - ``BlockOverrideDnsType`` - ``BlockOverrideDomain`` - ``BlockOverrideTtl``
             :param priority: The priority of the rule in the rule group. This value must be unique within the rule group. DNS Firewall processes the rules in a rule group by order of priority, starting from the lowest setting.
             :param block_override_dns_type: The DNS record's type. This determines the format of the record value that you provided in ``BlockOverrideDomain`` . Used for the rule action ``BLOCK`` with a ``BlockResponse`` setting of ``OVERRIDE`` .
             :param block_override_domain: The custom DNS record to send back in response to the query. Used for the rule action ``BLOCK`` with a ``BlockResponse`` setting of ``OVERRIDE`` .
@@ -793,7 +793,9 @@ class CfnFirewallRuleGroup(
 
         @builtins.property
         def action(self) -> builtins.str:
-            '''The action that DNS Firewall should take on a DNS query when it matches one of the domains in the rule's domain list:  - ``ALLOW`` - Permit the request to go through.
+            '''The action that DNS Firewall should take on a DNS query when it matches one of the domains in the rule's domain list, or a threat in a DNS Firewall Advvanced rule:  - ``ALLOW`` - Permit the request to go through.
+
+            Not available for DNS Firewall Advanced rules.
 
             - ``ALERT`` - Permit the request to go through but send an alert to the logs.
             - ``BLOCK`` - Disallow the request. If this is specified,then ``BlockResponse`` must also be specified.

aws_cdk/aws_s3/__init__.py

@@ -4244,7 +4244,7 @@ class CfnBucket(
         :param logging_configuration: Settings that define where logs are stored.
         :param metrics_configurations: Specifies a metrics configuration for the CloudWatch request metrics (specified by the metrics configuration ID) from an Amazon S3 bucket. If you're updating an existing metrics configuration, note that this is a full replacement of the existing metrics configuration. If you don't include the elements you want to keep, they are erased. For more information, see `PutBucketMetricsConfiguration <https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTMetricConfiguration.html>`_ .
         :param notification_configuration: Configuration that defines how Amazon S3 handles bucket notifications.
-        :param object_lock_configuration: .. epigraph:: This operation is not supported by directory buckets. Places an Object Lock configuration on the specified bucket. The rule specified in the Object Lock configuration will be applied by default to every new object placed in the specified bucket. For more information, see `Locking Objects <https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lock.html>`_ . .. epigraph:: - The ``DefaultRetention`` settings require both a mode and a period. - The ``DefaultRetention`` period can be either ``Days`` or ``Years`` but you must select one. You cannot specify ``Days`` and ``Years`` at the same time. - You can enable Object Lock for new or existing buckets. For more information, see `Configuring Object Lock <https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lock-configure.html>`_ .
+        :param object_lock_configuration: .. epigraph:: This operation is not supported for directory buckets. Places an Object Lock configuration on the specified bucket. The rule specified in the Object Lock configuration will be applied by default to every new object placed in the specified bucket. For more information, see `Locking Objects <https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lock.html>`_ . .. epigraph:: - The ``DefaultRetention`` settings require both a mode and a period. - The ``DefaultRetention`` period can be either ``Days`` or ``Years`` but you must select one. You cannot specify ``Days`` and ``Years`` at the same time. - You can enable Object Lock for new or existing buckets. For more information, see `Configuring Object Lock <https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lock-configure.html>`_ .
         :param object_lock_enabled: Indicates whether this bucket has an Object Lock configuration enabled. Enable ``ObjectLockEnabled`` when you apply ``ObjectLockConfiguration`` to a bucket.
         :param ownership_controls: Configuration that defines how Amazon S3 handles Object Ownership rules.
         :param public_access_block_configuration: Configuration that defines how Amazon S3 handles public access.
@@ -4597,7 +4597,7 @@ class CfnBucket(
     ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnBucket.ObjectLockConfigurationProperty"]]:
         '''.. epigraph::
 
-   This operation is not supported by directory buckets.'''
+   This operation is not supported for directory buckets.'''
         return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnBucket.ObjectLockConfigurationProperty"]], jsii.get(self, "objectLockConfiguration"))
 
     @object_lock_configuration.setter
@@ -10797,7 +10797,7 @@ class CfnBucketProps:
         :param logging_configuration: Settings that define where logs are stored.
         :param metrics_configurations: Specifies a metrics configuration for the CloudWatch request metrics (specified by the metrics configuration ID) from an Amazon S3 bucket. If you're updating an existing metrics configuration, note that this is a full replacement of the existing metrics configuration. If you don't include the elements you want to keep, they are erased. For more information, see `PutBucketMetricsConfiguration <https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTMetricConfiguration.html>`_ .
         :param notification_configuration: Configuration that defines how Amazon S3 handles bucket notifications.
-        :param object_lock_configuration: .. epigraph:: This operation is not supported by directory buckets. Places an Object Lock configuration on the specified bucket. The rule specified in the Object Lock configuration will be applied by default to every new object placed in the specified bucket. For more information, see `Locking Objects <https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lock.html>`_ . .. epigraph:: - The ``DefaultRetention`` settings require both a mode and a period. - The ``DefaultRetention`` period can be either ``Days`` or ``Years`` but you must select one. You cannot specify ``Days`` and ``Years`` at the same time. - You can enable Object Lock for new or existing buckets. For more information, see `Configuring Object Lock <https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lock-configure.html>`_ .
+        :param object_lock_configuration: .. epigraph:: This operation is not supported for directory buckets. Places an Object Lock configuration on the specified bucket. The rule specified in the Object Lock configuration will be applied by default to every new object placed in the specified bucket. For more information, see `Locking Objects <https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lock.html>`_ . .. epigraph:: - The ``DefaultRetention`` settings require both a mode and a period. - The ``DefaultRetention`` period can be either ``Days`` or ``Years`` but you must select one. You cannot specify ``Days`` and ``Years`` at the same time. - You can enable Object Lock for new or existing buckets. For more information, see `Configuring Object Lock <https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lock-configure.html>`_ .
         :param object_lock_enabled: Indicates whether this bucket has an Object Lock configuration enabled. Enable ``ObjectLockEnabled`` when you apply ``ObjectLockConfiguration`` to a bucket.
         :param ownership_controls: Configuration that defines how Amazon S3 handles Object Ownership rules.
         :param public_access_block_configuration: Configuration that defines how Amazon S3 handles public access.
@@ -11046,7 +11046,7 @@ class CfnBucketProps:
     ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnBucket.ObjectLockConfigurationProperty]]:
         '''.. epigraph::
 
-   This operation is not supported by directory buckets.
+   This operation is not supported for directory buckets.
 
         Places an Object Lock configuration on the specified bucket. The rule specified in the Object Lock configuration will be applied by default to every new object placed in the specified bucket. For more information, see `Locking Objects <https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lock.html>`_ .
         .. epigraph::