aws-cdk-lib 2.150.0__py3-none-any.whl → 2.151.1__py3-none-any.whl

aws_cdk/aws_elasticloadbalancingv2/__init__.py

@@ -470,6 +470,27 @@ tg = elbv2.ApplicationTargetGroup(self, "TG",
 )
 ```
 
+### Weighted random routing algorithms and automatic target weights for your Application Load Balancer
+
+You can use the `weighted_random` routing algorithms by setting the `loadBalancingAlgorithmType` property.
+
+When using this algorithm, Automatic Target Weights (ATW) anomaly mitigation can be used by setting `enableAnomalyMitigation` to `true`.
+
+Also you can't use this algorithm with slow start mode.
+
+For more information, see [Routing algorithms](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#modify-routing-algorithm) and [Automatic Target Weights (ATW)](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#automatic-target-weights).
+
+```python
+# vpc: ec2.Vpc
+
+
+tg = elbv2.ApplicationTargetGroup(self, "TargetGroup",
+    vpc=vpc,
+    load_balancing_algorithm_type=elbv2.TargetGroupLoadBalancingAlgorithmType.WEIGHTED_RANDOM,
+    enable_anomaly_mitigation=True
+)
+```
+
 ## Using Lambda Targets
 
 To use a Lambda Function as a target, use the integration class in the
@@ -11038,6 +11059,14 @@ class HttpCodeElb(enum.Enum):
     '''
     ELB_5XX_COUNT = "ELB_5XX_COUNT"
     '''The number of HTTP 5XX server error codes that originate from the load balancer.'''
+    ELB_500_COUNT = "ELB_500_COUNT"
+    '''The number of HTTP 500 server error codes that originate from the load balancer.'''
+    ELB_502_COUNT = "ELB_502_COUNT"
+    '''The number of HTTP 502 server error codes that originate from the load balancer.'''
+    ELB_503_COUNT = "ELB_503_COUNT"
+    '''The number of HTTP 503 server error codes that originate from the load balancer.'''
+    ELB_504_COUNT = "ELB_504_COUNT"
+    '''The number of HTTP 504 server error codes that originate from the load balancer.'''
 
 
 @jsii.enum(jsii_type="aws-cdk-lib.aws_elasticloadbalancingv2.HttpCodeTarget")
@@ -18041,12 +18070,28 @@ typing.cast(typing.Any, TargetGroupBase).__jsii_proxy_class__ = lambda : _Target
     jsii_type="aws-cdk-lib.aws_elasticloadbalancingv2.TargetGroupLoadBalancingAlgorithmType"
 )
 class TargetGroupLoadBalancingAlgorithmType(enum.Enum):
-    '''Load balancing algorithmm type for target groups.'''
+    '''Load balancing algorithmm type for target groups.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        # vpc: ec2.Vpc
+        
+        
+        tg = elbv2.ApplicationTargetGroup(self, "TargetGroup",
+            vpc=vpc,
+            load_balancing_algorithm_type=elbv2.TargetGroupLoadBalancingAlgorithmType.WEIGHTED_RANDOM,
+            enable_anomaly_mitigation=True
+        )
+    '''
 
     ROUND_ROBIN = "ROUND_ROBIN"
     '''round_robin.'''
     LEAST_OUTSTANDING_REQUESTS = "LEAST_OUTSTANDING_REQUESTS"
     '''least_outstanding_requests.'''
+    WEIGHTED_RANDOM = "WEIGHTED_RANDOM"
+    '''weighted_random.'''
 
 
 @jsii.enum(jsii_type="aws-cdk-lib.aws_elasticloadbalancingv2.TargetType")
@@ -18463,6 +18508,7 @@ class AddApplicationTargetGroupsProps(AddRuleProps):
         "conditions": "conditions",
         "priority": "priority",
         "deregistration_delay": "deregistrationDelay",
+        "enable_anomaly_mitigation": "enableAnomalyMitigation",
         "health_check": "healthCheck",
         "load_balancing_algorithm_type": "loadBalancingAlgorithmType",
         "port": "port",
@@ -18482,6 +18528,7 @@ class AddApplicationTargetsProps(AddRuleProps):
         conditions: typing.Optional[typing.Sequence[ListenerCondition]] = None,
         priority: typing.Optional[jsii.Number] = None,
         deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
+        enable_anomaly_mitigation: typing.Optional[builtins.bool] = None,
         health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
         load_balancing_algorithm_type: typing.Optional[TargetGroupLoadBalancingAlgorithmType] = None,
         port: typing.Optional[jsii.Number] = None,
@@ -18498,6 +18545,7 @@ class AddApplicationTargetsProps(AddRuleProps):
         :param conditions: Rule applies if matches the conditions. Default: - No conditions.
         :param priority: Priority of this target group. The rule with the lowest priority will be used for every request. If priority is not given, these target groups will be added as defaults, and must not have conditions. Priorities must be unique. Default: Target groups are used as defaults
         :param deregistration_delay: The amount of time for Elastic Load Balancing to wait before deregistering a target. The range is 0-3600 seconds. Default: Duration.minutes(5)
+        :param enable_anomaly_mitigation: Indicates whether anomaly mitigation is enabled. Only available when ``loadBalancingAlgorithmType`` is ``TargetGroupLoadBalancingAlgorithmType.WEIGHTED_RANDOM`` Default: false
         :param health_check: Health check configuration. Default: - The default value for each property in this configuration varies depending on the target.
         :param load_balancing_algorithm_type: The load balancing algorithm to select targets for routing requests. Default: round_robin.
         :param port: The port on which the listener listens for requests. Default: Determined from protocol if known
@@ -18550,6 +18598,7 @@ class AddApplicationTargetsProps(AddRuleProps):
             check_type(argname="argument conditions", value=conditions, expected_type=type_hints["conditions"])
             check_type(argname="argument priority", value=priority, expected_type=type_hints["priority"])
             check_type(argname="argument deregistration_delay", value=deregistration_delay, expected_type=type_hints["deregistration_delay"])
+            check_type(argname="argument enable_anomaly_mitigation", value=enable_anomaly_mitigation, expected_type=type_hints["enable_anomaly_mitigation"])
             check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument load_balancing_algorithm_type", value=load_balancing_algorithm_type, expected_type=type_hints["load_balancing_algorithm_type"])
             check_type(argname="argument port", value=port, expected_type=type_hints["port"])
@@ -18567,6 +18616,8 @@ class AddApplicationTargetsProps(AddRuleProps):
             self._values["priority"] = priority
         if deregistration_delay is not None:
             self._values["deregistration_delay"] = deregistration_delay
+        if enable_anomaly_mitigation is not None:
+            self._values["enable_anomaly_mitigation"] = enable_anomaly_mitigation
         if health_check is not None:
             self._values["health_check"] = health_check
         if load_balancing_algorithm_type is not None:
@@ -18625,6 +18676,19 @@ class AddApplicationTargetsProps(AddRuleProps):
         result = self._values.get("deregistration_delay")
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
 
+    @builtins.property
+    def enable_anomaly_mitigation(self) -> typing.Optional[builtins.bool]:
+        '''Indicates whether anomaly mitigation is enabled.
+
+        Only available when ``loadBalancingAlgorithmType`` is ``TargetGroupLoadBalancingAlgorithmType.WEIGHTED_RANDOM``
+
+        :default: false
+
+        :see: https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#automatic-target-weights
+        '''
+        result = self._values.get("enable_anomaly_mitigation")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
     @builtins.property
     def health_check(self) -> typing.Optional[HealthCheck]:
         '''Health check configuration.
@@ -19646,6 +19710,7 @@ class ApplicationLoadBalancerProps(BaseLoadBalancerProps):
         "target_group_name": "targetGroupName",
         "target_type": "targetType",
         "vpc": "vpc",
+        "enable_anomaly_mitigation": "enableAnomalyMitigation",
         "load_balancing_algorithm_type": "loadBalancingAlgorithmType",
         "port": "port",
         "protocol": "protocol",
@@ -19665,6 +19730,7 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
         target_group_name: typing.Optional[builtins.str] = None,
         target_type: typing.Optional[TargetType] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
+        enable_anomaly_mitigation: typing.Optional[builtins.bool] = None,
         load_balancing_algorithm_type: typing.Optional[TargetGroupLoadBalancingAlgorithmType] = None,
         port: typing.Optional[jsii.Number] = None,
         protocol: typing.Optional[ApplicationProtocol] = None,
@@ -19681,6 +19747,7 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
         :param target_group_name: The name of the target group. This name must be unique per region per account, can have a maximum of 32 characters, must contain only alphanumeric characters or hyphens, and must not begin or end with a hyphen. Default: - Automatically generated.
         :param target_type: The type of targets registered to this TargetGroup, either IP or Instance. All targets registered into the group must be of this type. If you register targets to the TargetGroup in the CDK app, the TargetType is determined automatically. Default: - Determined automatically.
         :param vpc: The virtual private cloud (VPC). only if ``TargetType`` is ``Ip`` or ``InstanceId`` Default: - undefined
+        :param enable_anomaly_mitigation: Indicates whether anomaly mitigation is enabled. Only available when ``loadBalancingAlgorithmType`` is ``TargetGroupLoadBalancingAlgorithmType.WEIGHTED_RANDOM`` Default: false
         :param load_balancing_algorithm_type: The load balancing algorithm to select targets for routing requests. Default: TargetGroupLoadBalancingAlgorithmType.ROUND_ROBIN
         :param port: The port on which the target receives traffic. This is not applicable for Lambda targets. Default: - Determined from protocol if known
         :param protocol: The protocol used for communication with the target. This is not applicable for Lambda targets. Default: - Determined from port if known
@@ -19697,15 +19764,11 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
             # vpc: ec2.Vpc
             
             
+            # Target group with slow start mode enabled
             tg = elbv2.ApplicationTargetGroup(self, "TG",
-                target_type=elbv2.TargetType.IP,
-                port=50051,
-                protocol=elbv2.ApplicationProtocol.HTTP,
-                protocol_version=elbv2.ApplicationProtocolVersion.GRPC,
-                health_check=elbv2.HealthCheck(
-                    enabled=True,
-                    healthy_grpc_codes="0-99"
-                ),
+                target_type=elbv2.TargetType.INSTANCE,
+                slow_start=Duration.seconds(60),
+                port=80,
                 vpc=vpc
             )
         '''
@@ -19718,6 +19781,7 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
             check_type(argname="argument target_group_name", value=target_group_name, expected_type=type_hints["target_group_name"])
             check_type(argname="argument target_type", value=target_type, expected_type=type_hints["target_type"])
             check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
+            check_type(argname="argument enable_anomaly_mitigation", value=enable_anomaly_mitigation, expected_type=type_hints["enable_anomaly_mitigation"])
             check_type(argname="argument load_balancing_algorithm_type", value=load_balancing_algorithm_type, expected_type=type_hints["load_balancing_algorithm_type"])
             check_type(argname="argument port", value=port, expected_type=type_hints["port"])
             check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
@@ -19737,6 +19801,8 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
             self._values["target_type"] = target_type
         if vpc is not None:
             self._values["vpc"] = vpc
+        if enable_anomaly_mitigation is not None:
+            self._values["enable_anomaly_mitigation"] = enable_anomaly_mitigation
         if load_balancing_algorithm_type is not None:
             self._values["load_balancing_algorithm_type"] = load_balancing_algorithm_type
         if port is not None:
@@ -19813,6 +19879,19 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
         result = self._values.get("vpc")
         return typing.cast(typing.Optional[_IVpc_f30d5663], result)
 
+    @builtins.property
+    def enable_anomaly_mitigation(self) -> typing.Optional[builtins.bool]:
+        '''Indicates whether anomaly mitigation is enabled.
+
+        Only available when ``loadBalancingAlgorithmType`` is ``TargetGroupLoadBalancingAlgorithmType.WEIGHTED_RANDOM``
+
+        :default: false
+
+        :see: https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#automatic-target-weights
+        '''
+        result = self._values.get("enable_anomaly_mitigation")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
     @builtins.property
     def load_balancing_algorithm_type(
         self,
@@ -20053,6 +20132,7 @@ class IApplicationListener(
         id: builtins.str,
         *,
         deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
+        enable_anomaly_mitigation: typing.Optional[builtins.bool] = None,
         health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
         load_balancing_algorithm_type: typing.Optional[TargetGroupLoadBalancingAlgorithmType] = None,
         port: typing.Optional[jsii.Number] = None,
@@ -20076,6 +20156,7 @@ class IApplicationListener(
 
         :param id: -
         :param deregistration_delay: The amount of time for Elastic Load Balancing to wait before deregistering a target. The range is 0-3600 seconds. Default: Duration.minutes(5)
+        :param enable_anomaly_mitigation: Indicates whether anomaly mitigation is enabled. Only available when ``loadBalancingAlgorithmType`` is ``TargetGroupLoadBalancingAlgorithmType.WEIGHTED_RANDOM`` Default: false
         :param health_check: Health check configuration. Default: - The default value for each property in this configuration varies depending on the target.
         :param load_balancing_algorithm_type: The load balancing algorithm to select targets for routing requests. Default: round_robin.
         :param port: The port on which the listener listens for requests. Default: Determined from protocol if known
@@ -20208,6 +20289,7 @@ class _IApplicationListenerProxy(
         id: builtins.str,
         *,
         deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
+        enable_anomaly_mitigation: typing.Optional[builtins.bool] = None,
         health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
         load_balancing_algorithm_type: typing.Optional[TargetGroupLoadBalancingAlgorithmType] = None,
         port: typing.Optional[jsii.Number] = None,
@@ -20231,6 +20313,7 @@ class _IApplicationListenerProxy(
 
         :param id: -
         :param deregistration_delay: The amount of time for Elastic Load Balancing to wait before deregistering a target. The range is 0-3600 seconds. Default: Duration.minutes(5)
+        :param enable_anomaly_mitigation: Indicates whether anomaly mitigation is enabled. Only available when ``loadBalancingAlgorithmType`` is ``TargetGroupLoadBalancingAlgorithmType.WEIGHTED_RANDOM`` Default: false
         :param health_check: Health check configuration. Default: - The default value for each property in this configuration varies depending on the target.
         :param load_balancing_algorithm_type: The load balancing algorithm to select targets for routing requests. Default: round_robin.
         :param port: The port on which the listener listens for requests. Default: Determined from protocol if known
@@ -20251,6 +20334,7 @@ class _IApplicationListenerProxy(
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
         props = AddApplicationTargetsProps(
             deregistration_delay=deregistration_delay,
+            enable_anomaly_mitigation=enable_anomaly_mitigation,
             health_check=health_check,
             load_balancing_algorithm_type=load_balancing_algorithm_type,
             port=port,
@@ -21395,6 +21479,7 @@ class ApplicationListener(
         id: builtins.str,
         *,
         deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
+        enable_anomaly_mitigation: typing.Optional[builtins.bool] = None,
         health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
         load_balancing_algorithm_type: typing.Optional[TargetGroupLoadBalancingAlgorithmType] = None,
         port: typing.Optional[jsii.Number] = None,
@@ -21421,6 +21506,7 @@ class ApplicationListener(
 
         :param id: -
         :param deregistration_delay: The amount of time for Elastic Load Balancing to wait before deregistering a target. The range is 0-3600 seconds. Default: Duration.minutes(5)
+        :param enable_anomaly_mitigation: Indicates whether anomaly mitigation is enabled. Only available when ``loadBalancingAlgorithmType`` is ``TargetGroupLoadBalancingAlgorithmType.WEIGHTED_RANDOM`` Default: false
         :param health_check: Health check configuration. Default: - The default value for each property in this configuration varies depending on the target.
         :param load_balancing_algorithm_type: The load balancing algorithm to select targets for routing requests. Default: round_robin.
         :param port: The port on which the listener listens for requests. Default: Determined from protocol if known
@@ -21441,6 +21527,7 @@ class ApplicationListener(
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
         props = AddApplicationTargetsProps(
             deregistration_delay=deregistration_delay,
+            enable_anomaly_mitigation=enable_anomaly_mitigation,
             health_check=health_check,
             load_balancing_algorithm_type=load_balancing_algorithm_type,
             port=port,
@@ -22858,6 +22945,7 @@ class ApplicationTargetGroup(
         scope: _constructs_77d1e7e8.Construct,
         id: builtins.str,
         *,
+        enable_anomaly_mitigation: typing.Optional[builtins.bool] = None,
         load_balancing_algorithm_type: typing.Optional[TargetGroupLoadBalancingAlgorithmType] = None,
         port: typing.Optional[jsii.Number] = None,
         protocol: typing.Optional[ApplicationProtocol] = None,
@@ -22875,6 +22963,7 @@ class ApplicationTargetGroup(
         '''
         :param scope: -
         :param id: -
+        :param enable_anomaly_mitigation: Indicates whether anomaly mitigation is enabled. Only available when ``loadBalancingAlgorithmType`` is ``TargetGroupLoadBalancingAlgorithmType.WEIGHTED_RANDOM`` Default: false
         :param load_balancing_algorithm_type: The load balancing algorithm to select targets for routing requests. Default: TargetGroupLoadBalancingAlgorithmType.ROUND_ROBIN
         :param port: The port on which the target receives traffic. This is not applicable for Lambda targets. Default: - Determined from protocol if known
         :param protocol: The protocol used for communication with the target. This is not applicable for Lambda targets. Default: - Determined from port if known
@@ -22894,6 +22983,7 @@ class ApplicationTargetGroup(
             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 = ApplicationTargetGroupProps(
+            enable_anomaly_mitigation=enable_anomaly_mitigation,
             load_balancing_algorithm_type=load_balancing_algorithm_type,
             port=port,
             protocol=protocol,
@@ -25288,6 +25378,7 @@ def _typecheckingstub__b26d56d500bb67c9d6ae66f1cb40dc7e2f3a670459278ff6a96edc676
     conditions: typing.Optional[typing.Sequence[ListenerCondition]] = None,
     priority: typing.Optional[jsii.Number] = None,
     deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
+    enable_anomaly_mitigation: typing.Optional[builtins.bool] = None,
     health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
     load_balancing_algorithm_type: typing.Optional[TargetGroupLoadBalancingAlgorithmType] = None,
     port: typing.Optional[jsii.Number] = None,
@@ -25378,6 +25469,7 @@ def _typecheckingstub__0fbf37aa0a91cb985ce7a336a6188364cc38400538c1653e53453287c
     target_group_name: typing.Optional[builtins.str] = None,
     target_type: typing.Optional[TargetType] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
+    enable_anomaly_mitigation: typing.Optional[builtins.bool] = None,
     load_balancing_algorithm_type: typing.Optional[TargetGroupLoadBalancingAlgorithmType] = None,
     port: typing.Optional[jsii.Number] = None,
     protocol: typing.Optional[ApplicationProtocol] = None,
@@ -25430,6 +25522,7 @@ def _typecheckingstub__84e790e0e8140f8df376ccc9404001adf95dc62c6408367a7fb37a7ac
     id: builtins.str,
     *,
     deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
+    enable_anomaly_mitigation: typing.Optional[builtins.bool] = None,
     health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
     load_balancing_algorithm_type: typing.Optional[TargetGroupLoadBalancingAlgorithmType] = None,
     port: typing.Optional[jsii.Number] = None,
@@ -25685,6 +25778,7 @@ def _typecheckingstub__024551e53e2a61ea5cc079e4909fa79f39b1b922c5d0ab7d4adfe8153
     id: builtins.str,
     *,
     deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
+    enable_anomaly_mitigation: typing.Optional[builtins.bool] = None,
     health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
     load_balancing_algorithm_type: typing.Optional[TargetGroupLoadBalancingAlgorithmType] = None,
     port: typing.Optional[jsii.Number] = None,
@@ -25835,6 +25929,7 @@ def _typecheckingstub__e179515c9d6138007cc1b74835b75f10a179c1f5ef977cbe4188c778c
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
     *,
+    enable_anomaly_mitigation: typing.Optional[builtins.bool] = None,
     load_balancing_algorithm_type: typing.Optional[TargetGroupLoadBalancingAlgorithmType] = None,
     port: typing.Optional[jsii.Number] = None,
     protocol: typing.Optional[ApplicationProtocol] = None,

aws_cdk/aws_entityresolution/__init__.py

@@ -140,7 +140,7 @@ class CfnIdMappingWorkflow(
         '''
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
-        :param id_mapping_techniques: An object which defines the ``idMappingType`` and the ``providerProperties`` .
+        :param id_mapping_techniques: An object which defines the ID mapping technique and any additional configurations.
         :param input_source_config: A list of ``InputSource`` objects, which have the fields ``InputSourceARN`` and ``SchemaName`` .
         :param role_arn: The Amazon Resource Name (ARN) of the IAM role. AWS Entity Resolution assumes this role to create resources on your behalf as part of workflow execution.
         :param workflow_name: The name of the workflow. There can't be multiple ``IdMappingWorkflows`` with the same name.
@@ -237,7 +237,7 @@ class CfnIdMappingWorkflow(
     def id_mapping_techniques(
         self,
     ) -> typing.Union[_IResolvable_da3f097b, "CfnIdMappingWorkflow.IdMappingTechniquesProperty"]:
-        '''An object which defines the ``idMappingType`` and the ``providerProperties`` .'''
+        '''An object which defines the ID mapping technique and any additional configurations.'''
         return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnIdMappingWorkflow.IdMappingTechniquesProperty"], jsii.get(self, "idMappingTechniques"))
 
     @id_mapping_techniques.setter
@@ -353,7 +353,7 @@ class CfnIdMappingWorkflow(
             id_mapping_type: typing.Optional[builtins.str] = None,
             provider_properties: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnIdMappingWorkflow.ProviderPropertiesProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         ) -> None:
-            '''An object which defines the ID mapping techniques and provider configurations.
+            '''An object which defines the ID mapping technique and any additional configurations.
 
             :param id_mapping_type: The type of ID mapping.
             :param provider_properties: An object which defines any additional configurations required by the provider service.
@@ -442,9 +442,9 @@ class CfnIdMappingWorkflow(
         ) -> None:
             '''An object containing ``InputSourceARN`` , ``SchemaName`` , and ``Type`` .
 
-            :param input_source_arn: An AWS Glue table ARN for the input source table.
+            :param input_source_arn: An AWS Glue table Amazon Resource Name (ARN) or a matching workflow ARN for the input source table.
             :param schema_arn: The ARN (Amazon Resource Name) that AWS Entity Resolution generated for the ``SchemaMapping`` .
-            :param type: The type of ID namespace. There are two types: ``SOURCE`` and ``TARGET`` . The ``SOURCE`` contains configurations for ``sourceId`` data that will be processed in an ID mapping workflow. The ``TARGET`` contains a configuration of ``targetId`` to which all ``sourceIds`` will resolve to.
+            :param type: The type of ID namespace. There are two types: ``SOURCE`` and ``TARGET`` . The ``SOURCE`` contains configurations for ``sourceId`` data that will be processed in an ID mapping workflow. The ``TARGET`` contains a configuration of ``targetId`` which all ``sourceIds`` will resolve to.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idmappingworkflow-idmappingworkflowinputsource.html
             :exampleMetadata: fixture=_generated
@@ -478,7 +478,7 @@ class CfnIdMappingWorkflow(
 
         @builtins.property
         def input_source_arn(self) -> builtins.str:
-            '''An AWS Glue table ARN for the input source table.
+            '''An AWS Glue table Amazon Resource Name (ARN) or a matching workflow ARN for the input source table.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idmappingworkflow-idmappingworkflowinputsource.html#cfn-entityresolution-idmappingworkflow-idmappingworkflowinputsource-inputsourcearn
             '''
@@ -501,7 +501,7 @@ class CfnIdMappingWorkflow(
 
             The ``SOURCE`` contains configurations for ``sourceId`` data that will be processed in an ID mapping workflow.
 
-            The ``TARGET`` contains a configuration of ``targetId`` to which all ``sourceIds`` will resolve to.
+            The ``TARGET`` contains a configuration of ``targetId`` which all ``sourceIds`` will resolve to.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idmappingworkflow-idmappingworkflowinputsource.html#cfn-entityresolution-idmappingworkflow-idmappingworkflowinputsource-type
             '''
@@ -780,7 +780,7 @@ class CfnIdMappingWorkflowProps:
     ) -> None:
         '''Properties for defining a ``CfnIdMappingWorkflow``.
 
-        :param id_mapping_techniques: An object which defines the ``idMappingType`` and the ``providerProperties`` .
+        :param id_mapping_techniques: An object which defines the ID mapping technique and any additional configurations.
         :param input_source_config: A list of ``InputSource`` objects, which have the fields ``InputSourceARN`` and ``SchemaName`` .
         :param role_arn: The Amazon Resource Name (ARN) of the IAM role. AWS Entity Resolution assumes this role to create resources on your behalf as part of workflow execution.
         :param workflow_name: The name of the workflow. There can't be multiple ``IdMappingWorkflows`` with the same name.
@@ -862,7 +862,7 @@ class CfnIdMappingWorkflowProps:
     def id_mapping_techniques(
         self,
     ) -> typing.Union[_IResolvable_da3f097b, CfnIdMappingWorkflow.IdMappingTechniquesProperty]:
-        '''An object which defines the ``idMappingType`` and the ``providerProperties`` .
+        '''An object which defines the ID mapping technique and any additional configurations.
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-entityresolution-idmappingworkflow.html#cfn-entityresolution-idmappingworkflow-idmappingtechniques
         '''
@@ -1017,7 +1017,7 @@ class CfnIdNamespace(
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
         :param id_namespace_name: The name of the ID namespace.
-        :param type: The type of ID namespace. There are two types: ``SOURCE`` and ``TARGET`` . The ``SOURCE`` contains configurations for ``sourceId`` data that will be processed in an ID mapping workflow. The ``TARGET`` contains a configuration of ``targetId`` to which all ``sourceIds`` will resolve to.
+        :param type: The type of ID namespace. There are two types: ``SOURCE`` and ``TARGET`` . The ``SOURCE`` contains configurations for ``sourceId`` data that will be processed in an ID mapping workflow. The ``TARGET`` contains a configuration of ``targetId`` which all ``sourceIds`` will resolve to.
         :param description: The description of the ID namespace.
         :param id_mapping_workflow_properties: Determines the properties of ``IdMappingWorflow`` where this ``IdNamespace`` can be used as a ``Source`` or a ``Target`` .
         :param input_source_config: A list of ``InputSource`` objects, which have the fields ``InputSourceARN`` and ``SchemaName`` .
@@ -1227,7 +1227,7 @@ class CfnIdNamespace(
             id_mapping_type: builtins.str,
             provider_properties: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnIdNamespace.NamespaceProviderPropertiesProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         ) -> None:
-            '''An object containing ``IdMappingType`` and ``ProviderProperties`` .
+            '''An object containing ``IdMappingType`` , ``ProviderProperties`` , and ``RuleBasedProperties`` .
 
             :param id_mapping_type: The type of ID mapping.
             :param provider_properties: An object which defines any additional configurations required by the provider service.
@@ -1314,7 +1314,7 @@ class CfnIdNamespace(
         ) -> None:
             '''An object containing ``InputSourceARN`` and ``SchemaName`` .
 
-            :param input_source_arn: An AWS Glue table ARN for the input source table.
+            :param input_source_arn: An AWS Glue table Amazon Resource Name (ARN) or a matching workflow ARN for the input source table.
             :param schema_name: The name of the schema.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idnamespace-idnamespaceinputsource.html
@@ -1345,7 +1345,7 @@ class CfnIdNamespace(
 
         @builtins.property
         def input_source_arn(self) -> builtins.str:
-            '''An AWS Glue table ARN for the input source table.
+            '''An AWS Glue table Amazon Resource Name (ARN) or a matching workflow ARN for the input source table.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idnamespace-idnamespaceinputsource.html#cfn-entityresolution-idnamespace-idnamespaceinputsource-inputsourcearn
             '''
@@ -1482,7 +1482,7 @@ class CfnIdNamespaceProps:
         '''Properties for defining a ``CfnIdNamespace``.
 
         :param id_namespace_name: The name of the ID namespace.
-        :param type: The type of ID namespace. There are two types: ``SOURCE`` and ``TARGET`` . The ``SOURCE`` contains configurations for ``sourceId`` data that will be processed in an ID mapping workflow. The ``TARGET`` contains a configuration of ``targetId`` to which all ``sourceIds`` will resolve to.
+        :param type: The type of ID namespace. There are two types: ``SOURCE`` and ``TARGET`` . The ``SOURCE`` contains configurations for ``sourceId`` data that will be processed in an ID mapping workflow. The ``TARGET`` contains a configuration of ``targetId`` which all ``sourceIds`` will resolve to.
         :param description: The description of the ID namespace.
         :param id_mapping_workflow_properties: Determines the properties of ``IdMappingWorflow`` where this ``IdNamespace`` can be used as a ``Source`` or a ``Target`` .
         :param input_source_config: A list of ``InputSource`` objects, which have the fields ``InputSourceARN`` and ``SchemaName`` .
@@ -1570,7 +1570,7 @@ class CfnIdNamespaceProps:
 
         The ``SOURCE`` contains configurations for ``sourceId`` data that will be processed in an ID mapping workflow.
 
-        The ``TARGET`` contains a configuration of ``targetId`` to which all ``sourceIds`` will resolve to.
+        The ``TARGET`` contains a configuration of ``targetId`` which all ``sourceIds`` will resolve to.
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-entityresolution-idnamespace.html#cfn-entityresolution-idnamespace-type
         '''
@@ -2513,9 +2513,11 @@ class CfnMatchingWorkflow(
             attribute_matching_model: builtins.str,
             rules: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnMatchingWorkflow.RuleProperty", typing.Dict[builtins.str, typing.Any]]]]],
         ) -> None:
-            '''An object which defines the list of matching rules to run and has a field ``Rules`` , which is a list of rule objects.
+            '''An object which defines the list of matching rules to run in a matching workflow.
+
+            RuleBasedProperties contain a ``Rules`` field, which is a list of rule objects.
 
-            :param attribute_matching_model: The comparison type. You can either choose ``ONE_TO_ONE`` or ``MANY_TO_MANY`` as the AttributeMatchingModel. When choosing ``MANY_TO_MANY`` , the system can match attributes across the sub-types of an attribute type. For example, if the value of the ``Email`` field of Profile A and the value of ``BusinessEmail`` field of Profile B matches, the two profiles are matched on the ``Email`` type. When choosing ``ONE_TO_ONE`` ,the system can only match if the sub-types are exact matches. For example, only when the value of the ``Email`` field of Profile A and the value of the ``Email`` field of Profile B matches, the two profiles are matched on the ``Email`` type.
+            :param attribute_matching_model: The comparison type. You can either choose ``ONE_TO_ONE`` or ``MANY_TO_MANY`` as the ``attributeMatchingModel`` . If you choose ``MANY_TO_MANY`` , the system can match attributes across the sub-types of an attribute type. For example, if the value of the ``Email`` field of Profile A and the value of ``BusinessEmail`` field of Profile B matches, the two profiles are matched on the ``Email`` attribute type. If you choose ``ONE_TO_ONE`` , the system can only match attributes if the sub-types are an exact match. For example, for the ``Email`` attribute type, the system will only consider it a match if the value of the ``Email`` field of Profile A matches the value of the ``Email`` field of Profile B.
             :param rules: A list of ``Rule`` objects, each of which have fields ``RuleName`` and ``MatchingKeys`` .
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-matchingworkflow-rulebasedproperties.html
@@ -2546,9 +2548,11 @@ class CfnMatchingWorkflow(
 
         @builtins.property
         def attribute_matching_model(self) -> builtins.str:
-            '''The comparison type.
+            '''The comparison type. You can either choose ``ONE_TO_ONE`` or ``MANY_TO_MANY`` as the ``attributeMatchingModel`` .
 
-            You can either choose ``ONE_TO_ONE`` or ``MANY_TO_MANY`` as the AttributeMatchingModel. When choosing ``MANY_TO_MANY`` , the system can match attributes across the sub-types of an attribute type. For example, if the value of the ``Email`` field of Profile A and the value of ``BusinessEmail`` field of Profile B matches, the two profiles are matched on the ``Email`` type. When choosing ``ONE_TO_ONE`` ,the system can only match if the sub-types are exact matches. For example, only when the value of the ``Email`` field of Profile A and the value of the ``Email`` field of Profile B matches, the two profiles are matched on the ``Email`` type.
+            If you choose ``MANY_TO_MANY`` , the system can match attributes across the sub-types of an attribute type. For example, if the value of the ``Email`` field of Profile A and the value of ``BusinessEmail`` field of Profile B matches, the two profiles are matched on the ``Email`` attribute type.
+
+            If you choose ``ONE_TO_ONE`` , the system can only match attributes if the sub-types are an exact match. For example, for the ``Email`` attribute type, the system will only consider it a match if the value of the ``Email`` field of Profile A matches the value of the ``Email`` field of Profile B.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-matchingworkflow-rulebasedproperties.html#cfn-entityresolution-matchingworkflow-rulebasedproperties-attributematchingmodel
             '''
@@ -3418,7 +3422,7 @@ class CfnSchemaMapping(
             match_key: typing.Optional[builtins.str] = None,
             sub_type: typing.Optional[builtins.str] = None,
         ) -> None:
-            '''An object containing ``FieldName`` , ``Type`` , ``GroupName`` , ``MatchKey`` , and ``SubType`` .
+            '''An object containing ``FieldName`` , ``Type`` , ``GroupName`` , ``MatchKey`` , ``Hashing`` , and ``SubType`` .
 
             :param field_name: A string containing the field name.
             :param type: The type of the attribute, selected from a list of values.
@@ -3498,7 +3502,9 @@ class CfnSchemaMapping(
         def match_key(self) -> typing.Optional[builtins.str]:
             '''A key that allows grouping of multiple input attributes into a unified matching group.
 
-            For example, consider a scenario where the source table contains various addresses, such as ``business_address`` and ``shipping_address`` . By assigning a ``matchKey`` called ``address`` to both attributes, AWS Entity Resolution will match records across these fields to create a consolidated matching group. If no ``matchKey`` is specified for a column, it won't be utilized for matching purposes but will still be included in the output table.
+            For example, consider a scenario where the source table contains various addresses, such as ``business_address`` and ``shipping_address`` . By assigning a ``matchKey`` called ``address`` to both attributes, AWS Entity Resolution will match records across these fields to create a consolidated matching group.
+
+            If no ``matchKey`` is specified for a column, it won't be utilized for matching purposes but will still be included in the output table.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-schemamapping-schemainputattribute.html#cfn-entityresolution-schemamapping-schemainputattribute-matchkey
             '''