aws-cdk-lib 2.153.0__py3-none-any.whl → 2.154.1__py3-none-any.whl

aws_cdk/aws_entityresolution/__init__.py

@@ -97,6 +97,17 @@ class CfnIdMappingWorkflow(
                     provider_configuration={
                         "provider_configuration_key": "providerConfiguration"
                     }
+                ),
+                rule_based_properties=entityresolution.CfnIdMappingWorkflow.IdMappingRuleBasedPropertiesProperty(
+                    attribute_matching_model="attributeMatchingModel",
+                    record_matching_model="recordMatchingModel",
+        
+                    # the properties below are optional
+                    rule_definition_type="ruleDefinitionType",
+                    rules=[entityresolution.CfnIdMappingWorkflow.RuleProperty(
+                        matching_keys=["matchingKeys"],
+                        rule_name="ruleName"
+                    )]
                 )
             ),
             input_source_config=[entityresolution.CfnIdMappingWorkflow.IdMappingWorkflowInputSourceProperty(
@@ -248,7 +259,7 @@ class CfnIdMappingWorkflow(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__98386f6c6b4518a801b696fa8f0f873daefcfe1d2a7891af04eaf6e011722023)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "idMappingTechniques", value)
+        jsii.set(self, "idMappingTechniques", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="inputSourceConfig")
@@ -266,7 +277,7 @@ class CfnIdMappingWorkflow(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__4a9193affb5fa4439a48ce7bed8e4da128d477cf32b5570d11bbf2989fbb8c87)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "inputSourceConfig", value)
+        jsii.set(self, "inputSourceConfig", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="roleArn")
@@ -279,7 +290,7 @@ class CfnIdMappingWorkflow(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__0590ee667206f813442b789a06c4cb886b668b0e9b9dffab96674a6875e8e692)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "roleArn", value)
+        jsii.set(self, "roleArn", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="workflowName")
@@ -292,7 +303,7 @@ class CfnIdMappingWorkflow(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__b8d56686a0d9a714685134d0c5102241eaf1010135accbde2a09a29a15196fd2)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "workflowName", value)
+        jsii.set(self, "workflowName", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="description")
@@ -305,7 +316,7 @@ class CfnIdMappingWorkflow(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__73508385219d92414fa73246ef135667c9eca037d9a796d5490e9c29dc374cfc)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "description", value)
+        jsii.set(self, "description", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="outputSourceConfig")
@@ -323,7 +334,7 @@ class CfnIdMappingWorkflow(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__c441bfde4467a201e4e9322b69a020514feb4e0efb56d31892f1f02e461d7119)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "outputSourceConfig", value)
+        jsii.set(self, "outputSourceConfig", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="tags")
@@ -336,7 +347,130 @@ class CfnIdMappingWorkflow(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__f1c5de5e1db5e25e42cb52039b70835fa351dc563f560ac5ff3604bab3a7c6d3)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "tags", value)
+        jsii.set(self, "tags", value) # pyright: ignore[reportArgumentType]
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_entityresolution.CfnIdMappingWorkflow.IdMappingRuleBasedPropertiesProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "attribute_matching_model": "attributeMatchingModel",
+            "record_matching_model": "recordMatchingModel",
+            "rule_definition_type": "ruleDefinitionType",
+            "rules": "rules",
+        },
+    )
+    class IdMappingRuleBasedPropertiesProperty:
+        def __init__(
+            self,
+            *,
+            attribute_matching_model: builtins.str,
+            record_matching_model: builtins.str,
+            rule_definition_type: typing.Optional[builtins.str] = None,
+            rules: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnIdMappingWorkflow.RuleProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
+        ) -> None:
+            '''An object that defines the list of matching rules to run in an ID mapping workflow.
+
+            :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 matches the value of the ``BusinessEmail`` field of Profile B, 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 record_matching_model: The type of matching record that is allowed to be used in an ID mapping workflow. If the value is set to ``ONE_SOURCE_TO_ONE_TARGET`` , only one record in the source can be matched to the same record in the target. If the value is set to ``MANY_SOURCE_TO_ONE_TARGET`` , multiple records in the source can be matched to one record in the target.
+            :param rule_definition_type: The set of rules you can use in an ID mapping workflow. The limitations specified for the source or target to define the match rules must be compatible.
+            :param rules: The rules that can be used for ID mapping.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idmappingworkflow-idmappingrulebasedproperties.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_entityresolution as entityresolution
+                
+                id_mapping_rule_based_properties_property = entityresolution.CfnIdMappingWorkflow.IdMappingRuleBasedPropertiesProperty(
+                    attribute_matching_model="attributeMatchingModel",
+                    record_matching_model="recordMatchingModel",
+                
+                    # the properties below are optional
+                    rule_definition_type="ruleDefinitionType",
+                    rules=[entityresolution.CfnIdMappingWorkflow.RuleProperty(
+                        matching_keys=["matchingKeys"],
+                        rule_name="ruleName"
+                    )]
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__4bb92f6ba90c637e6800332c85746dca9a127a9d4ac3f6130ef5f9057e52d644)
+                check_type(argname="argument attribute_matching_model", value=attribute_matching_model, expected_type=type_hints["attribute_matching_model"])
+                check_type(argname="argument record_matching_model", value=record_matching_model, expected_type=type_hints["record_matching_model"])
+                check_type(argname="argument rule_definition_type", value=rule_definition_type, expected_type=type_hints["rule_definition_type"])
+                check_type(argname="argument rules", value=rules, expected_type=type_hints["rules"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "attribute_matching_model": attribute_matching_model,
+                "record_matching_model": record_matching_model,
+            }
+            if rule_definition_type is not None:
+                self._values["rule_definition_type"] = rule_definition_type
+            if rules is not None:
+                self._values["rules"] = rules
+
+        @builtins.property
+        def attribute_matching_model(self) -> builtins.str:
+            '''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 matches the value of the ``BusinessEmail`` field of Profile B, 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-idmappingworkflow-idmappingrulebasedproperties.html#cfn-entityresolution-idmappingworkflow-idmappingrulebasedproperties-attributematchingmodel
+            '''
+            result = self._values.get("attribute_matching_model")
+            assert result is not None, "Required property 'attribute_matching_model' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def record_matching_model(self) -> builtins.str:
+            '''The type of matching record that is allowed to be used in an ID mapping workflow.
+
+            If the value is set to ``ONE_SOURCE_TO_ONE_TARGET`` , only one record in the source can be matched to the same record in the target.
+
+            If the value is set to ``MANY_SOURCE_TO_ONE_TARGET`` , multiple records in the source can be matched to one record in the target.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idmappingworkflow-idmappingrulebasedproperties.html#cfn-entityresolution-idmappingworkflow-idmappingrulebasedproperties-recordmatchingmodel
+            '''
+            result = self._values.get("record_matching_model")
+            assert result is not None, "Required property 'record_matching_model' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def rule_definition_type(self) -> typing.Optional[builtins.str]:
+            '''The set of rules you can use in an ID mapping workflow.
+
+            The limitations specified for the source or target to define the match rules must be compatible.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idmappingworkflow-idmappingrulebasedproperties.html#cfn-entityresolution-idmappingworkflow-idmappingrulebasedproperties-ruledefinitiontype
+            '''
+            result = self._values.get("rule_definition_type")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def rules(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnIdMappingWorkflow.RuleProperty"]]]]:
+            '''The rules that can be used for ID mapping.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idmappingworkflow-idmappingrulebasedproperties.html#cfn-entityresolution-idmappingworkflow-idmappingrulebasedproperties-rules
+            '''
+            result = self._values.get("rules")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnIdMappingWorkflow.RuleProperty"]]]], 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 "IdMappingRuleBasedPropertiesProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
 
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_entityresolution.CfnIdMappingWorkflow.IdMappingTechniquesProperty",
@@ -344,6 +478,7 @@ class CfnIdMappingWorkflow(
         name_mapping={
             "id_mapping_type": "idMappingType",
             "provider_properties": "providerProperties",
+            "rule_based_properties": "ruleBasedProperties",
         },
     )
     class IdMappingTechniquesProperty:
@@ -352,11 +487,13 @@ 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,
+            rule_based_properties: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnIdMappingWorkflow.IdMappingRuleBasedPropertiesProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         ) -> None:
             '''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.
+            :param rule_based_properties: An object which defines any additional configurations required by rule-based matching.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idmappingworkflow-idmappingtechniques.html
             :exampleMetadata: fixture=_generated
@@ -379,6 +516,17 @@ class CfnIdMappingWorkflow(
                         provider_configuration={
                             "provider_configuration_key": "providerConfiguration"
                         }
+                    ),
+                    rule_based_properties=entityresolution.CfnIdMappingWorkflow.IdMappingRuleBasedPropertiesProperty(
+                        attribute_matching_model="attributeMatchingModel",
+                        record_matching_model="recordMatchingModel",
+                
+                        # the properties below are optional
+                        rule_definition_type="ruleDefinitionType",
+                        rules=[entityresolution.CfnIdMappingWorkflow.RuleProperty(
+                            matching_keys=["matchingKeys"],
+                            rule_name="ruleName"
+                        )]
                     )
                 )
             '''
@@ -386,11 +534,14 @@ class CfnIdMappingWorkflow(
                 type_hints = typing.get_type_hints(_typecheckingstub__14f084baf89be97b69b754d6755f29c921f7ef9044bf1e234a903b93f7718bcc)
                 check_type(argname="argument id_mapping_type", value=id_mapping_type, expected_type=type_hints["id_mapping_type"])
                 check_type(argname="argument provider_properties", value=provider_properties, expected_type=type_hints["provider_properties"])
+                check_type(argname="argument rule_based_properties", value=rule_based_properties, expected_type=type_hints["rule_based_properties"])
             self._values: typing.Dict[builtins.str, typing.Any] = {}
             if id_mapping_type is not None:
                 self._values["id_mapping_type"] = id_mapping_type
             if provider_properties is not None:
                 self._values["provider_properties"] = provider_properties
+            if rule_based_properties is not None:
+                self._values["rule_based_properties"] = rule_based_properties
 
         @builtins.property
         def id_mapping_type(self) -> typing.Optional[builtins.str]:
@@ -412,6 +563,17 @@ class CfnIdMappingWorkflow(
             result = self._values.get("provider_properties")
             return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnIdMappingWorkflow.ProviderPropertiesProperty"]], result)
 
+        @builtins.property
+        def rule_based_properties(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnIdMappingWorkflow.IdMappingRuleBasedPropertiesProperty"]]:
+            '''An object which defines any additional configurations required by rule-based matching.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idmappingworkflow-idmappingtechniques.html#cfn-entityresolution-idmappingworkflow-idmappingtechniques-rulebasedproperties
+            '''
+            result = self._values.get("rule_based_properties")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnIdMappingWorkflow.IdMappingRuleBasedPropertiesProperty"]], result)
+
         def __eq__(self, rhs: typing.Any) -> builtins.bool:
             return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -752,6 +914,79 @@ class CfnIdMappingWorkflow(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_entityresolution.CfnIdMappingWorkflow.RuleProperty",
+        jsii_struct_bases=[],
+        name_mapping={"matching_keys": "matchingKeys", "rule_name": "ruleName"},
+    )
+    class RuleProperty:
+        def __init__(
+            self,
+            *,
+            matching_keys: typing.Sequence[builtins.str],
+            rule_name: builtins.str,
+        ) -> None:
+            '''An object containing ``RuleName`` , and ``MatchingKeys`` .
+
+            :param matching_keys: A list of ``MatchingKeys`` . The ``MatchingKeys`` must have been defined in the ``SchemaMapping`` . Two records are considered to match according to this rule if all of the ``MatchingKeys`` match.
+            :param rule_name: A name for the matching rule.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idmappingworkflow-rule.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_entityresolution as entityresolution
+                
+                rule_property = entityresolution.CfnIdMappingWorkflow.RuleProperty(
+                    matching_keys=["matchingKeys"],
+                    rule_name="ruleName"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__9a2722d057e717d3981c452673ade46182ba7a7c53c282a417854ec754ea6c36)
+                check_type(argname="argument matching_keys", value=matching_keys, expected_type=type_hints["matching_keys"])
+                check_type(argname="argument rule_name", value=rule_name, expected_type=type_hints["rule_name"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "matching_keys": matching_keys,
+                "rule_name": rule_name,
+            }
+
+        @builtins.property
+        def matching_keys(self) -> typing.List[builtins.str]:
+            '''A list of ``MatchingKeys`` .
+
+            The ``MatchingKeys`` must have been defined in the ``SchemaMapping`` . Two records are considered to match according to this rule if all of the ``MatchingKeys`` match.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idmappingworkflow-rule.html#cfn-entityresolution-idmappingworkflow-rule-matchingkeys
+            '''
+            result = self._values.get("matching_keys")
+            assert result is not None, "Required property 'matching_keys' is missing"
+            return typing.cast(typing.List[builtins.str], result)
+
+        @builtins.property
+        def rule_name(self) -> builtins.str:
+            '''A name for the matching rule.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idmappingworkflow-rule.html#cfn-entityresolution-idmappingworkflow-rule-rulename
+            '''
+            result = self._values.get("rule_name")
+            assert result is not None, "Required property 'rule_name' is missing"
+            return typing.cast(builtins.str, result)
+
+        def __eq__(self, rhs: typing.Any) -> builtins.bool:
+            return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+        def __ne__(self, rhs: typing.Any) -> builtins.bool:
+            return not (rhs == self)
+
+        def __repr__(self) -> str:
+            return "RuleProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
 
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_entityresolution.CfnIdMappingWorkflowProps",
@@ -810,6 +1045,17 @@ class CfnIdMappingWorkflowProps:
                         provider_configuration={
                             "provider_configuration_key": "providerConfiguration"
                         }
+                    ),
+                    rule_based_properties=entityresolution.CfnIdMappingWorkflow.IdMappingRuleBasedPropertiesProperty(
+                        attribute_matching_model="attributeMatchingModel",
+                        record_matching_model="recordMatchingModel",
+            
+                        # the properties below are optional
+                        rule_definition_type="ruleDefinitionType",
+                        rules=[entityresolution.CfnIdMappingWorkflow.RuleProperty(
+                            matching_keys=["matchingKeys"],
+                            rule_name="ruleName"
+                        )]
                     )
                 ),
                 input_source_config=[entityresolution.CfnIdMappingWorkflow.IdMappingWorkflowInputSourceProperty(
@@ -984,6 +1230,15 @@ class CfnIdNamespace(
                     provider_configuration={
                         "provider_configuration_key": "providerConfiguration"
                     }
+                ),
+                rule_based_properties=entityresolution.CfnIdNamespace.NamespaceRuleBasedPropertiesProperty(
+                    attribute_matching_model="attributeMatchingModel",
+                    record_matching_models=["recordMatchingModels"],
+                    rule_definition_types=["ruleDefinitionTypes"],
+                    rules=[entityresolution.CfnIdNamespace.RuleProperty(
+                        matching_keys=["matchingKeys"],
+                        rule_name="ruleName"
+                    )]
                 )
             )],
             input_source_config=[entityresolution.CfnIdNamespace.IdNamespaceInputSourceProperty(
@@ -1119,7 +1374,7 @@ class CfnIdNamespace(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__f6edc56662f23af984d5dabe222f6a5f7a29873d00db9469fa30becc99669015)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "idNamespaceName", value)
+        jsii.set(self, "idNamespaceName", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="type")
@@ -1135,7 +1390,7 @@ class CfnIdNamespace(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__59aa3cddc506bb9301e306fc65a81fe2f3d9a2d8f6325f117b73c0cdfb3383f0)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "type", value)
+        jsii.set(self, "type", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="description")
@@ -1148,7 +1403,7 @@ class CfnIdNamespace(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__62808fb43ceca295eefdf3d9bf0915cc4c583c943ab92427f8ad0c90b7041c27)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "description", value)
+        jsii.set(self, "description", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="idMappingWorkflowProperties")
@@ -1166,7 +1421,7 @@ class CfnIdNamespace(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__bf3f06822761d2f6d3dffb9e7372b2e0adbfdbe7d2d1a69ccbf7fe76c0cd3563)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "idMappingWorkflowProperties", value)
+        jsii.set(self, "idMappingWorkflowProperties", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="inputSourceConfig")
@@ -1184,7 +1439,7 @@ class CfnIdNamespace(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__07ed70fcfed9befc6606046de0c338bb1c3c4a34f8857c885f1ee4de60a117a5)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "inputSourceConfig", value)
+        jsii.set(self, "inputSourceConfig", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="roleArn")
@@ -1197,7 +1452,7 @@ class CfnIdNamespace(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__94c305262a4b68819464007b072179d90eca1c2de79673e950550fcc4c13e4da)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "roleArn", value)
+        jsii.set(self, "roleArn", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="tags")
@@ -1210,7 +1465,7 @@ class CfnIdNamespace(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__8f05afda3b318f866f888a36136617b66dbba80a6134a0504f9adc95f42fbdff)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "tags", value)
+        jsii.set(self, "tags", value) # pyright: ignore[reportArgumentType]
 
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_entityresolution.CfnIdNamespace.IdNamespaceIdMappingWorkflowPropertiesProperty",
@@ -1218,6 +1473,7 @@ class CfnIdNamespace(
         name_mapping={
             "id_mapping_type": "idMappingType",
             "provider_properties": "providerProperties",
+            "rule_based_properties": "ruleBasedProperties",
         },
     )
     class IdNamespaceIdMappingWorkflowPropertiesProperty:
@@ -1226,11 +1482,13 @@ 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,
+            rule_based_properties: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnIdNamespace.NamespaceRuleBasedPropertiesProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         ) -> None:
             '''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.
+            :param rule_based_properties: An object which defines any additional configurations required by rule-based matching.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idnamespace-idnamespaceidmappingworkflowproperties.html
             :exampleMetadata: fixture=_generated
@@ -1252,6 +1510,15 @@ class CfnIdNamespace(
                         provider_configuration={
                             "provider_configuration_key": "providerConfiguration"
                         }
+                    ),
+                    rule_based_properties=entityresolution.CfnIdNamespace.NamespaceRuleBasedPropertiesProperty(
+                        attribute_matching_model="attributeMatchingModel",
+                        record_matching_models=["recordMatchingModels"],
+                        rule_definition_types=["ruleDefinitionTypes"],
+                        rules=[entityresolution.CfnIdNamespace.RuleProperty(
+                            matching_keys=["matchingKeys"],
+                            rule_name="ruleName"
+                        )]
                     )
                 )
             '''
@@ -1259,11 +1526,14 @@ class CfnIdNamespace(
                 type_hints = typing.get_type_hints(_typecheckingstub__0fc06bed3ebb2bebac13d7f812581356c393a6004c7ebcc6cfeb91e46afa58b5)
                 check_type(argname="argument id_mapping_type", value=id_mapping_type, expected_type=type_hints["id_mapping_type"])
                 check_type(argname="argument provider_properties", value=provider_properties, expected_type=type_hints["provider_properties"])
+                check_type(argname="argument rule_based_properties", value=rule_based_properties, expected_type=type_hints["rule_based_properties"])
             self._values: typing.Dict[builtins.str, typing.Any] = {
                 "id_mapping_type": id_mapping_type,
             }
             if provider_properties is not None:
                 self._values["provider_properties"] = provider_properties
+            if rule_based_properties is not None:
+                self._values["rule_based_properties"] = rule_based_properties
 
         @builtins.property
         def id_mapping_type(self) -> builtins.str:
@@ -1286,6 +1556,17 @@ class CfnIdNamespace(
             result = self._values.get("provider_properties")
             return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnIdNamespace.NamespaceProviderPropertiesProperty"]], result)
 
+        @builtins.property
+        def rule_based_properties(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnIdNamespace.NamespaceRuleBasedPropertiesProperty"]]:
+            '''An object which defines any additional configurations required by rule-based matching.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idnamespace-idnamespaceidmappingworkflowproperties.html#cfn-entityresolution-idnamespace-idnamespaceidmappingworkflowproperties-rulebasedproperties
+            '''
+            result = self._values.get("rule_based_properties")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnIdNamespace.NamespaceRuleBasedPropertiesProperty"]], result)
+
         def __eq__(self, rhs: typing.Any) -> builtins.bool:
             return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -1453,6 +1734,201 @@ class CfnIdNamespace(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_entityresolution.CfnIdNamespace.NamespaceRuleBasedPropertiesProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "attribute_matching_model": "attributeMatchingModel",
+            "record_matching_models": "recordMatchingModels",
+            "rule_definition_types": "ruleDefinitionTypes",
+            "rules": "rules",
+        },
+    )
+    class NamespaceRuleBasedPropertiesProperty:
+        def __init__(
+            self,
+            *,
+            attribute_matching_model: typing.Optional[builtins.str] = None,
+            record_matching_models: typing.Optional[typing.Sequence[builtins.str]] = None,
+            rule_definition_types: typing.Optional[typing.Sequence[builtins.str]] = None,
+            rules: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnIdNamespace.RuleProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
+        ) -> None:
+            '''The rule-based properties of an ID namespace.
+
+            These properties define how the ID namespace can be used in an ID mapping workflow.
+
+            :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 matches the value of ``BusinessEmail`` field of Profile B, 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 record_matching_models: 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 matches the value of ``BusinessEmail`` field of Profile B, 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 rule_definition_types: The sets of rules you can use in an ID mapping workflow. The limitations specified for the source and target must be compatible.
+            :param rules: The rules for the ID namespace.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idnamespace-namespacerulebasedproperties.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_entityresolution as entityresolution
+                
+                namespace_rule_based_properties_property = entityresolution.CfnIdNamespace.NamespaceRuleBasedPropertiesProperty(
+                    attribute_matching_model="attributeMatchingModel",
+                    record_matching_models=["recordMatchingModels"],
+                    rule_definition_types=["ruleDefinitionTypes"],
+                    rules=[entityresolution.CfnIdNamespace.RuleProperty(
+                        matching_keys=["matchingKeys"],
+                        rule_name="ruleName"
+                    )]
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__8bfae40336a06990deb46082eaf84fc7c08dfb1e350147ac63e7816023036424)
+                check_type(argname="argument attribute_matching_model", value=attribute_matching_model, expected_type=type_hints["attribute_matching_model"])
+                check_type(argname="argument record_matching_models", value=record_matching_models, expected_type=type_hints["record_matching_models"])
+                check_type(argname="argument rule_definition_types", value=rule_definition_types, expected_type=type_hints["rule_definition_types"])
+                check_type(argname="argument rules", value=rules, expected_type=type_hints["rules"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if attribute_matching_model is not None:
+                self._values["attribute_matching_model"] = attribute_matching_model
+            if record_matching_models is not None:
+                self._values["record_matching_models"] = record_matching_models
+            if rule_definition_types is not None:
+                self._values["rule_definition_types"] = rule_definition_types
+            if rules is not None:
+                self._values["rules"] = rules
+
+        @builtins.property
+        def attribute_matching_model(self) -> typing.Optional[builtins.str]:
+            '''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 matches the value of ``BusinessEmail`` field of Profile B, 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-idnamespace-namespacerulebasedproperties.html#cfn-entityresolution-idnamespace-namespacerulebasedproperties-attributematchingmodel
+            '''
+            result = self._values.get("attribute_matching_model")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def record_matching_models(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''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 matches the value of ``BusinessEmail`` field of Profile B, 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-idnamespace-namespacerulebasedproperties.html#cfn-entityresolution-idnamespace-namespacerulebasedproperties-recordmatchingmodels
+            '''
+            result = self._values.get("record_matching_models")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+        @builtins.property
+        def rule_definition_types(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''The sets of rules you can use in an ID mapping workflow.
+
+            The limitations specified for the source and target must be compatible.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idnamespace-namespacerulebasedproperties.html#cfn-entityresolution-idnamespace-namespacerulebasedproperties-ruledefinitiontypes
+            '''
+            result = self._values.get("rule_definition_types")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+        @builtins.property
+        def rules(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnIdNamespace.RuleProperty"]]]]:
+            '''The rules for the ID namespace.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idnamespace-namespacerulebasedproperties.html#cfn-entityresolution-idnamespace-namespacerulebasedproperties-rules
+            '''
+            result = self._values.get("rules")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnIdNamespace.RuleProperty"]]]], 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 "NamespaceRuleBasedPropertiesProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_entityresolution.CfnIdNamespace.RuleProperty",
+        jsii_struct_bases=[],
+        name_mapping={"matching_keys": "matchingKeys", "rule_name": "ruleName"},
+    )
+    class RuleProperty:
+        def __init__(
+            self,
+            *,
+            matching_keys: typing.Sequence[builtins.str],
+            rule_name: builtins.str,
+        ) -> None:
+            '''An object containing ``RuleName`` , and ``MatchingKeys`` .
+
+            :param matching_keys: A list of ``MatchingKeys`` . The ``MatchingKeys`` must have been defined in the ``SchemaMapping`` . Two records are considered to match according to this rule if all of the ``MatchingKeys`` match.
+            :param rule_name: A name for the matching rule.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idnamespace-rule.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_entityresolution as entityresolution
+                
+                rule_property = entityresolution.CfnIdNamespace.RuleProperty(
+                    matching_keys=["matchingKeys"],
+                    rule_name="ruleName"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__a7b7b4615999e81b09ce8264e01ece7b6902a9159ab61791c90867353cc0609d)
+                check_type(argname="argument matching_keys", value=matching_keys, expected_type=type_hints["matching_keys"])
+                check_type(argname="argument rule_name", value=rule_name, expected_type=type_hints["rule_name"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "matching_keys": matching_keys,
+                "rule_name": rule_name,
+            }
+
+        @builtins.property
+        def matching_keys(self) -> typing.List[builtins.str]:
+            '''A list of ``MatchingKeys`` .
+
+            The ``MatchingKeys`` must have been defined in the ``SchemaMapping`` . Two records are considered to match according to this rule if all of the ``MatchingKeys`` match.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idnamespace-rule.html#cfn-entityresolution-idnamespace-rule-matchingkeys
+            '''
+            result = self._values.get("matching_keys")
+            assert result is not None, "Required property 'matching_keys' is missing"
+            return typing.cast(typing.List[builtins.str], result)
+
+        @builtins.property
+        def rule_name(self) -> builtins.str:
+            '''A name for the matching rule.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idnamespace-rule.html#cfn-entityresolution-idnamespace-rule-rulename
+            '''
+            result = self._values.get("rule_name")
+            assert result is not None, "Required property 'rule_name' is missing"
+            return typing.cast(builtins.str, result)
+
+        def __eq__(self, rhs: typing.Any) -> builtins.bool:
+            return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+        def __ne__(self, rhs: typing.Any) -> builtins.bool:
+            return not (rhs == self)
+
+        def __repr__(self) -> str:
+            return "RuleProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
 
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_entityresolution.CfnIdNamespaceProps",
@@ -1515,6 +1991,15 @@ class CfnIdNamespaceProps:
                         provider_configuration={
                             "provider_configuration_key": "providerConfiguration"
                         }
+                    ),
+                    rule_based_properties=entityresolution.CfnIdNamespace.NamespaceRuleBasedPropertiesProperty(
+                        attribute_matching_model="attributeMatchingModel",
+                        record_matching_models=["recordMatchingModels"],
+                        rule_definition_types=["ruleDefinitionTypes"],
+                        rules=[entityresolution.CfnIdNamespace.RuleProperty(
+                            matching_keys=["matchingKeys"],
+                            rule_name="ruleName"
+                        )]
                     )
                 )],
                 input_source_config=[entityresolution.CfnIdNamespace.IdNamespaceInputSourceProperty(
@@ -1700,7 +2185,10 @@ class CfnMatchingWorkflow(
                     rules=[entityresolution.CfnMatchingWorkflow.RuleProperty(
                         matching_keys=["matchingKeys"],
                         rule_name="ruleName"
-                    )]
+                    )],
+        
+                    # the properties below are optional
+                    match_purpose="matchPurpose"
                 )
             ),
             role_arn="roleArn",
@@ -1839,7 +2327,7 @@ class CfnMatchingWorkflow(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__46336e1b290b62290456cef0086653d1bf7bde247391e85b7b88570883b249d6)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "inputSourceConfig", value)
+        jsii.set(self, "inputSourceConfig", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="outputSourceConfig")
@@ -1857,7 +2345,7 @@ class CfnMatchingWorkflow(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__f6752620fe10a272a45c22eb2493e5e30fcac8bb82fcc95b6f46271727dadc72)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "outputSourceConfig", value)
+        jsii.set(self, "outputSourceConfig", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="resolutionTechniques")
@@ -1875,7 +2363,7 @@ class CfnMatchingWorkflow(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__bfbb583351458ecc2896a0f04d4bae86260e8762b28c2687fe570562260a9a48)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "resolutionTechniques", value)
+        jsii.set(self, "resolutionTechniques", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="roleArn")
@@ -1888,7 +2376,7 @@ class CfnMatchingWorkflow(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__a68dfd5a70e354a050b7085c6c4cc4520862c51d487a8a8e920928f222fa1894)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "roleArn", value)
+        jsii.set(self, "roleArn", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="workflowName")
@@ -1901,7 +2389,7 @@ class CfnMatchingWorkflow(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__92e33fb06ce08c9c2af24c4cb3e68018f92d9bc69c0f62bc965ba1640232fd73)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "workflowName", value)
+        jsii.set(self, "workflowName", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="description")
@@ -1914,7 +2402,7 @@ class CfnMatchingWorkflow(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__146028c4441df7c65ea8aba2981fe23a6e2fda2af137f4c78d1c5c84d63a3b1a)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "description", value)
+        jsii.set(self, "description", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="tags")
@@ -1927,7 +2415,7 @@ class CfnMatchingWorkflow(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__a7a7896d7bea53a4e2ffc9445d9a42b8864f5ac9a6cf43c3b27fe3c77bd39a83)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "tags", value)
+        jsii.set(self, "tags", value) # pyright: ignore[reportArgumentType]
 
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_entityresolution.CfnMatchingWorkflow.InputSourceProperty",
@@ -2437,7 +2925,10 @@ class CfnMatchingWorkflow(
                         rules=[entityresolution.CfnMatchingWorkflow.RuleProperty(
                             matching_keys=["matchingKeys"],
                             rule_name="ruleName"
-                        )]
+                        )],
+                
+                        # the properties below are optional
+                        match_purpose="matchPurpose"
                     )
                 )
             '''
@@ -2504,6 +2995,7 @@ class CfnMatchingWorkflow(
         name_mapping={
             "attribute_matching_model": "attributeMatchingModel",
             "rules": "rules",
+            "match_purpose": "matchPurpose",
         },
     )
     class RuleBasedPropertiesProperty:
@@ -2512,6 +3004,7 @@ 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]]]]],
+            match_purpose: typing.Optional[builtins.str] = None,
         ) -> None:
             '''An object which defines the list of matching rules to run in a matching workflow.
 
@@ -2519,6 +3012,7 @@ class CfnMatchingWorkflow(
 
             :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`` .
+            :param match_purpose: An indicator of whether to generate IDs and index the data or not. If you choose ``IDENTIFIER_GENERATION`` , the process generates IDs and indexes the data. If you choose ``INDEXING`` , the process indexes the data without generating IDs.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-matchingworkflow-rulebasedproperties.html
             :exampleMetadata: fixture=_generated
@@ -2534,17 +3028,23 @@ class CfnMatchingWorkflow(
                     rules=[entityresolution.CfnMatchingWorkflow.RuleProperty(
                         matching_keys=["matchingKeys"],
                         rule_name="ruleName"
-                    )]
+                    )],
+                
+                    # the properties below are optional
+                    match_purpose="matchPurpose"
                 )
             '''
             if __debug__:
                 type_hints = typing.get_type_hints(_typecheckingstub__96d1f97c0110dea5fb9a8413e199ae25878eedad10521ad056ca772f31ddb8ba)
                 check_type(argname="argument attribute_matching_model", value=attribute_matching_model, expected_type=type_hints["attribute_matching_model"])
                 check_type(argname="argument rules", value=rules, expected_type=type_hints["rules"])
+                check_type(argname="argument match_purpose", value=match_purpose, expected_type=type_hints["match_purpose"])
             self._values: typing.Dict[builtins.str, typing.Any] = {
                 "attribute_matching_model": attribute_matching_model,
                 "rules": rules,
             }
+            if match_purpose is not None:
+                self._values["match_purpose"] = match_purpose
 
         @builtins.property
         def attribute_matching_model(self) -> builtins.str:
@@ -2572,6 +3072,19 @@ class CfnMatchingWorkflow(
             assert result is not None, "Required property 'rules' is missing"
             return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnMatchingWorkflow.RuleProperty"]]], result)
 
+        @builtins.property
+        def match_purpose(self) -> typing.Optional[builtins.str]:
+            '''An indicator of whether to generate IDs and index the data or not.
+
+            If you choose ``IDENTIFIER_GENERATION`` , the process generates IDs and indexes the data.
+
+            If you choose ``INDEXING`` , the process indexes the data without generating IDs.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-matchingworkflow-rulebasedproperties.html#cfn-entityresolution-matchingworkflow-rulebasedproperties-matchpurpose
+            '''
+            result = self._values.get("match_purpose")
+            return typing.cast(typing.Optional[builtins.str], result)
+
         def __eq__(self, rhs: typing.Any) -> builtins.bool:
             return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -2740,7 +3253,10 @@ class CfnMatchingWorkflowProps:
                         rules=[entityresolution.CfnMatchingWorkflow.RuleProperty(
                             matching_keys=["matchingKeys"],
                             rule_name="ruleName"
-                        )]
+                        )],
+            
+                        # the properties below are optional
+                        match_purpose="matchPurpose"
                     )
                 ),
                 role_arn="roleArn",
@@ -2980,7 +3496,7 @@ class CfnPolicyStatement(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__a8767fe619cb5d75047f318db538baa5ab3a27e058ca0111a4c24271fa51ff40)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "arn", value)
+        jsii.set(self, "arn", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="statementId")
@@ -2993,7 +3509,7 @@ class CfnPolicyStatement(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__851fa2b0339949709c645934229c92c57e76587d0add6dfff788c8b6881d496e)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "statementId", value)
+        jsii.set(self, "statementId", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="action")
@@ -3006,7 +3522,7 @@ class CfnPolicyStatement(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__5c31374cbb6b747ff8aad15e2ba0bcfcf581e9276e6193ea7fea9fc51c170da5)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "action", value)
+        jsii.set(self, "action", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="condition")
@@ -3019,7 +3535,7 @@ class CfnPolicyStatement(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__9ff6ca47c90dc8044522eb4fdc13f8e8fd3817f4dd78f5c13503a9ddcac783da)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "condition", value)
+        jsii.set(self, "condition", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="effect")
@@ -3032,7 +3548,7 @@ class CfnPolicyStatement(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__1f137f4492e162960ce48c9f3937faa9cdc691f98387867695272278e19efeda)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "effect", value)
+        jsii.set(self, "effect", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="principal")
@@ -3045,7 +3561,7 @@ class CfnPolicyStatement(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__d0f1297ccea599d72dd52d3bb273838ce431126a148b946f018fb1f6316e8a42)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "principal", value)
+        jsii.set(self, "principal", value) # pyright: ignore[reportArgumentType]
 
 
 @jsii.data_type(
@@ -3222,6 +3738,7 @@ class CfnSchemaMapping(
         
                 # the properties below are optional
                 group_name="groupName",
+                hashed=False,
                 match_key="matchKey",
                 sub_type="subType"
             )],
@@ -3360,7 +3877,7 @@ class CfnSchemaMapping(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__582cf934b619d5bd24742b664e76c854f1f5f978250eb7c8b069eea939a36d15)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "mappedInputFields", value)
+        jsii.set(self, "mappedInputFields", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="schemaName")
@@ -3373,7 +3890,7 @@ class CfnSchemaMapping(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__2e60d6efab6fe4d38d530b8bf0a9230db6dd3ba98b56dfb812bea973c5fb07fb)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "schemaName", value)
+        jsii.set(self, "schemaName", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="description")
@@ -3386,7 +3903,7 @@ class CfnSchemaMapping(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__45aaef5bf11ec7b2bf48bfb15f820ed7b15b4ae8a5c668df859ffb21058df8e7)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "description", value)
+        jsii.set(self, "description", value) # pyright: ignore[reportArgumentType]
 
     @builtins.property
     @jsii.member(jsii_name="tags")
@@ -3399,7 +3916,7 @@ class CfnSchemaMapping(
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__eb00d34c669b02d875a4d122d6517a31b19c4fe763a25a3d3e60b62a88dc81c6)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "tags", value)
+        jsii.set(self, "tags", value) # pyright: ignore[reportArgumentType]
 
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_entityresolution.CfnSchemaMapping.SchemaInputAttributeProperty",
@@ -3408,6 +3925,7 @@ class CfnSchemaMapping(
             "field_name": "fieldName",
             "type": "type",
             "group_name": "groupName",
+            "hashed": "hashed",
             "match_key": "matchKey",
             "sub_type": "subType",
         },
@@ -3419,6 +3937,7 @@ class CfnSchemaMapping(
             field_name: builtins.str,
             type: builtins.str,
             group_name: typing.Optional[builtins.str] = None,
+            hashed: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
             match_key: typing.Optional[builtins.str] = None,
             sub_type: typing.Optional[builtins.str] = None,
         ) -> None:
@@ -3427,6 +3946,7 @@ class CfnSchemaMapping(
             :param field_name: A string containing the field name.
             :param type: The type of the attribute, selected from a list of values.
             :param group_name: A string that instructs AWS Entity Resolution to combine several columns into a unified column with the identical attribute type. For example, when working with columns such as ``first_name`` , ``middle_name`` , and ``last_name`` , assigning them a common ``groupName`` will prompt AWS Entity Resolution to concatenate them into a single value.
+            :param hashed: Indicates if the column values are hashed in the schema input. If the value is set to ``TRUE`` , the column values are hashed. If the value is set to ``FALSE`` , the column values are cleartext.
             :param match_key: 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.
             :param sub_type: The subtype of the attribute, selected from a list of values.
 
@@ -3445,6 +3965,7 @@ class CfnSchemaMapping(
                 
                     # the properties below are optional
                     group_name="groupName",
+                    hashed=False,
                     match_key="matchKey",
                     sub_type="subType"
                 )
@@ -3454,6 +3975,7 @@ class CfnSchemaMapping(
                 check_type(argname="argument field_name", value=field_name, expected_type=type_hints["field_name"])
                 check_type(argname="argument type", value=type, expected_type=type_hints["type"])
                 check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
+                check_type(argname="argument hashed", value=hashed, expected_type=type_hints["hashed"])
                 check_type(argname="argument match_key", value=match_key, expected_type=type_hints["match_key"])
                 check_type(argname="argument sub_type", value=sub_type, expected_type=type_hints["sub_type"])
             self._values: typing.Dict[builtins.str, typing.Any] = {
@@ -3462,6 +3984,8 @@ class CfnSchemaMapping(
             }
             if group_name is not None:
                 self._values["group_name"] = group_name
+            if hashed is not None:
+                self._values["hashed"] = hashed
             if match_key is not None:
                 self._values["match_key"] = match_key
             if sub_type is not None:
@@ -3498,6 +4022,19 @@ class CfnSchemaMapping(
             result = self._values.get("group_name")
             return typing.cast(typing.Optional[builtins.str], result)
 
+        @builtins.property
+        def hashed(
+            self,
+        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+            '''Indicates if the column values are hashed in the schema input.
+
+            If the value is set to ``TRUE`` , the column values are hashed. If the value is set to ``FALSE`` , the column values are cleartext.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-schemamapping-schemainputattribute.html#cfn-entityresolution-schemamapping-schemainputattribute-hashed
+            '''
+            result = self._values.get("hashed")
+            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
+
         @builtins.property
         def match_key(self) -> typing.Optional[builtins.str]:
             '''A key that allows grouping of multiple input attributes into a unified matching group.
@@ -3574,6 +4111,7 @@ class CfnSchemaMappingProps:
             
                     # the properties below are optional
                     group_name="groupName",
+                    hashed=False,
                     match_key="matchKey",
                     sub_type="subType"
                 )],
@@ -3742,10 +4280,21 @@ def _typecheckingstub__f1c5de5e1db5e25e42cb52039b70835fa351dc563f560ac5ff3604bab
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__4bb92f6ba90c637e6800332c85746dca9a127a9d4ac3f6130ef5f9057e52d644(
+    *,
+    attribute_matching_model: builtins.str,
+    record_matching_model: builtins.str,
+    rule_definition_type: typing.Optional[builtins.str] = None,
+    rules: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIdMappingWorkflow.RuleProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__14f084baf89be97b69b754d6755f29c921f7ef9044bf1e234a903b93f7718bcc(
     *,
     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,
+    rule_based_properties: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIdMappingWorkflow.IdMappingRuleBasedPropertiesProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -3783,6 +4332,14 @@ def _typecheckingstub__14038cffce86b081db1c8ac49ebcf0ca7c79dab49ef3c8d99bd5529be
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__9a2722d057e717d3981c452673ade46182ba7a7c53c282a417854ec754ea6c36(
+    *,
+    matching_keys: typing.Sequence[builtins.str],
+    rule_name: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__a92ec1b5f460936930fefdd0c239f69c3ec93198e4a71c3867bbe1bf1a48bf11(
     *,
     id_mapping_techniques: typing.Union[_IResolvable_da3f097b, typing.Union[CfnIdMappingWorkflow.IdMappingTechniquesProperty, typing.Dict[builtins.str, typing.Any]]],
@@ -3869,6 +4426,7 @@ def _typecheckingstub__0fc06bed3ebb2bebac13d7f812581356c393a6004c7ebcc6cfeb91e46
     *,
     id_mapping_type: builtins.str,
     provider_properties: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIdNamespace.NamespaceProviderPropertiesProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    rule_based_properties: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIdNamespace.NamespaceRuleBasedPropertiesProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -3889,6 +4447,24 @@ def _typecheckingstub__8d5dbe88736667d56bc74050ba3debedc70aa5658eb42d955598a1141
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__8bfae40336a06990deb46082eaf84fc7c08dfb1e350147ac63e7816023036424(
+    *,
+    attribute_matching_model: typing.Optional[builtins.str] = None,
+    record_matching_models: typing.Optional[typing.Sequence[builtins.str]] = None,
+    rule_definition_types: typing.Optional[typing.Sequence[builtins.str]] = None,
+    rules: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIdNamespace.RuleProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__a7b7b4615999e81b09ce8264e01ece7b6902a9159ab61791c90867353cc0609d(
+    *,
+    matching_keys: typing.Sequence[builtins.str],
+    rule_name: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__08dbceaf6584c6ddec9cc5b62fe86da5739412407f6e361f15be9f4533370973(
     *,
     id_namespace_name: builtins.str,
@@ -4027,6 +4603,7 @@ def _typecheckingstub__96d1f97c0110dea5fb9a8413e199ae25878eedad10521ad056ca772f3
     *,
     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]]]]],
+    match_purpose: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -4179,6 +4756,7 @@ def _typecheckingstub__d608d145fae97c0a85e57f344f3785207a465f180330e5a7bec62b411
     field_name: builtins.str,
     type: builtins.str,
     group_name: typing.Optional[builtins.str] = None,
+    hashed: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     match_key: typing.Optional[builtins.str] = None,
     sub_type: typing.Optional[builtins.str] = None,
 ) -> None: