aws-cdk-lib 2.155.0__py3-none-any.whl → 2.157.0__py3-none-any.whl

aws_cdk/aws_entityresolution/__init__.py

@@ -1758,7 +1758,7 @@ class CfnIdNamespace(
             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 record_matching_models: 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 is matched to one record in the target. If the value is set to ``MANY_SOURCE_TO_ONE_TARGET`` , all matching records in the source are matched to one record in the target.
             :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.
 
@@ -1812,11 +1812,11 @@ class CfnIdNamespace(
 
         @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`` .
+            '''The type of matching record that is allowed to be used in an ID mapping workflow.
 
-            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 the value is set to ``ONE_SOURCE_TO_ONE_TARGET`` , only one record in the source is matched to one record in the target.
 
-            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.
+            If the value is set to ``MANY_SOURCE_TO_ONE_TARGET`` , all matching records in the source are matched to one record in the target.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-idnamespace-namespacerulebasedproperties.html#cfn-entityresolution-idnamespace-namespacerulebasedproperties-recordmatchingmodels
             '''
@@ -2196,6 +2196,9 @@ class CfnMatchingWorkflow(
         
             # the properties below are optional
             description="description",
+            incremental_run_config=entityresolution.CfnMatchingWorkflow.IncrementalRunConfigProperty(
+                incremental_run_type="incrementalRunType"
+            ),
             tags=[CfnTag(
                 key="key",
                 value="value"
@@ -2214,6 +2217,7 @@ class CfnMatchingWorkflow(
         role_arn: builtins.str,
         workflow_name: builtins.str,
         description: typing.Optional[builtins.str] = None,
+        incremental_run_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnMatchingWorkflow.IncrementalRunConfigProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
         '''
@@ -2225,6 +2229,7 @@ class CfnMatchingWorkflow(
         :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 ``MatchingWorkflows`` with the same name.
         :param description: A description of the workflow.
+        :param incremental_run_config: An object which defines an incremental run type and has only ``incrementalRunType`` as a field.
         :param tags: The tags used to organize, track, or control access for this resource.
         '''
         if __debug__:
@@ -2238,6 +2243,7 @@ class CfnMatchingWorkflow(
             role_arn=role_arn,
             workflow_name=workflow_name,
             description=description,
+            incremental_run_config=incremental_run_config,
             tags=tags,
         )
 
@@ -2404,6 +2410,24 @@ class CfnMatchingWorkflow(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "description", value) # pyright: ignore[reportArgumentType]
 
+    @builtins.property
+    @jsii.member(jsii_name="incrementalRunConfig")
+    def incremental_run_config(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnMatchingWorkflow.IncrementalRunConfigProperty"]]:
+        '''An object which defines an incremental run type and has only ``incrementalRunType`` as a field.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnMatchingWorkflow.IncrementalRunConfigProperty"]], jsii.get(self, "incrementalRunConfig"))
+
+    @incremental_run_config.setter
+    def incremental_run_config(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnMatchingWorkflow.IncrementalRunConfigProperty"]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__fdee84f9bb03bc6201cd3324ee7101913cc3ab4894303fd18c5ddddd2246eac3)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "incrementalRunConfig", value) # pyright: ignore[reportArgumentType]
+
     @builtins.property
     @jsii.member(jsii_name="tags")
     def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
@@ -2417,6 +2441,60 @@ class CfnMatchingWorkflow(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "tags", value) # pyright: ignore[reportArgumentType]
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_entityresolution.CfnMatchingWorkflow.IncrementalRunConfigProperty",
+        jsii_struct_bases=[],
+        name_mapping={"incremental_run_type": "incrementalRunType"},
+    )
+    class IncrementalRunConfigProperty:
+        def __init__(self, *, incremental_run_type: builtins.str) -> None:
+            '''An object which defines an incremental run type and has only ``incrementalRunType`` as a field.
+
+            :param incremental_run_type: The type of incremental run. It takes only one value: ``IMMEDIATE`` .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-matchingworkflow-incrementalrunconfig.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
+                
+                incremental_run_config_property = entityresolution.CfnMatchingWorkflow.IncrementalRunConfigProperty(
+                    incremental_run_type="incrementalRunType"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__e88ed5ec9e5f2edc300dbdd925bb99b748b330b8e099b18f65b28da2cb124640)
+                check_type(argname="argument incremental_run_type", value=incremental_run_type, expected_type=type_hints["incremental_run_type"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "incremental_run_type": incremental_run_type,
+            }
+
+        @builtins.property
+        def incremental_run_type(self) -> builtins.str:
+            '''The type of incremental run.
+
+            It takes only one value: ``IMMEDIATE`` .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-entityresolution-matchingworkflow-incrementalrunconfig.html#cfn-entityresolution-matchingworkflow-incrementalrunconfig-incrementalruntype
+            '''
+            result = self._values.get("incremental_run_type")
+            assert result is not None, "Required property 'incremental_run_type' 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 "IncrementalRunConfigProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_entityresolution.CfnMatchingWorkflow.InputSourceProperty",
         jsii_struct_bases=[],
@@ -3180,6 +3258,7 @@ class CfnMatchingWorkflow(
         "role_arn": "roleArn",
         "workflow_name": "workflowName",
         "description": "description",
+        "incremental_run_config": "incrementalRunConfig",
         "tags": "tags",
     },
 )
@@ -3193,6 +3272,7 @@ class CfnMatchingWorkflowProps:
         role_arn: builtins.str,
         workflow_name: builtins.str,
         description: typing.Optional[builtins.str] = None,
+        incremental_run_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnMatchingWorkflow.IncrementalRunConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
         '''Properties for defining a ``CfnMatchingWorkflow``.
@@ -3203,6 +3283,7 @@ class CfnMatchingWorkflowProps:
         :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 ``MatchingWorkflows`` with the same name.
         :param description: A description of the workflow.
+        :param incremental_run_config: An object which defines an incremental run type and has only ``incrementalRunType`` as a field.
         :param tags: The tags used to organize, track, or control access for this resource.
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-entityresolution-matchingworkflow.html
@@ -3264,6 +3345,9 @@ class CfnMatchingWorkflowProps:
             
                 # the properties below are optional
                 description="description",
+                incremental_run_config=entityresolution.CfnMatchingWorkflow.IncrementalRunConfigProperty(
+                    incremental_run_type="incrementalRunType"
+                ),
                 tags=[CfnTag(
                     key="key",
                     value="value"
@@ -3278,6 +3362,7 @@ class CfnMatchingWorkflowProps:
             check_type(argname="argument role_arn", value=role_arn, expected_type=type_hints["role_arn"])
             check_type(argname="argument workflow_name", value=workflow_name, expected_type=type_hints["workflow_name"])
             check_type(argname="argument description", value=description, expected_type=type_hints["description"])
+            check_type(argname="argument incremental_run_config", value=incremental_run_config, expected_type=type_hints["incremental_run_config"])
             check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "input_source_config": input_source_config,
@@ -3288,6 +3373,8 @@ class CfnMatchingWorkflowProps:
         }
         if description is not None:
             self._values["description"] = description
+        if incremental_run_config is not None:
+            self._values["incremental_run_config"] = incremental_run_config
         if tags is not None:
             self._values["tags"] = tags
 
@@ -3360,6 +3447,17 @@ class CfnMatchingWorkflowProps:
         result = self._values.get("description")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def incremental_run_config(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnMatchingWorkflow.IncrementalRunConfigProperty]]:
+        '''An object which defines an incremental run type and has only ``incrementalRunType`` as a field.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-entityresolution-matchingworkflow.html#cfn-entityresolution-matchingworkflow-incrementalrunconfig
+        '''
+        result = self._values.get("incremental_run_config")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnMatchingWorkflow.IncrementalRunConfigProperty]], result)
+
     @builtins.property
     def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
         '''The tags used to organize, track, or control access for this resource.
@@ -4488,6 +4586,7 @@ def _typecheckingstub__8c9e9b620b89ac2aae774eb42384e0472b5a13eeb28983708b164b240
     role_arn: builtins.str,
     workflow_name: builtins.str,
     description: typing.Optional[builtins.str] = None,
+    incremental_run_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnMatchingWorkflow.IncrementalRunConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
     """Type checking stubs"""
@@ -4541,12 +4640,25 @@ def _typecheckingstub__146028c4441df7c65ea8aba2981fe23a6e2fda2af137f4c78d1c5c84d
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__fdee84f9bb03bc6201cd3324ee7101913cc3ab4894303fd18c5ddddd2246eac3(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnMatchingWorkflow.IncrementalRunConfigProperty]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__a7a7896d7bea53a4e2ffc9445d9a42b8864f5ac9a6cf43c3b27fe3c77bd39a83(
     value: typing.Optional[typing.List[_CfnTag_f6864754]],
 ) -> None:
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__e88ed5ec9e5f2edc300dbdd925bb99b748b330b8e099b18f65b28da2cb124640(
+    *,
+    incremental_run_type: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__6a18bfef9ee8ade2fff3913e22cf37d98f5880893c2204caa684a7f3831327af(
     *,
     input_source_arn: builtins.str,
@@ -4624,6 +4736,7 @@ def _typecheckingstub__2be3b46399b509a45bb640cf4a70ab0714322917a6d3dc4c241cb16ab
     role_arn: builtins.str,
     workflow_name: builtins.str,
     description: typing.Optional[builtins.str] = None,
+    incremental_run_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnMatchingWorkflow.IncrementalRunConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
     """Type checking stubs"""

aws_cdk/aws_events/__init__.py

@@ -10276,6 +10276,7 @@ class RuleProps(EventCommonOptions):
         "http_parameters": "httpParameters",
         "input": "input",
         "kinesis_parameters": "kinesisParameters",
+        "redshift_data_parameters": "redshiftDataParameters",
         "retry_policy": "retryPolicy",
         "role": "role",
         "run_command_parameters": "runCommandParameters",
@@ -10295,6 +10296,7 @@ class RuleTargetConfig:
         http_parameters: typing.Optional[typing.Union[CfnRule.HttpParametersProperty, typing.Dict[builtins.str, typing.Any]]] = None,
         input: typing.Optional["RuleTargetInput"] = None,
         kinesis_parameters: typing.Optional[typing.Union[CfnRule.KinesisParametersProperty, typing.Dict[builtins.str, typing.Any]]] = None,
+        redshift_data_parameters: typing.Optional[typing.Union[CfnRule.RedshiftDataParametersProperty, typing.Dict[builtins.str, typing.Any]]] = None,
         retry_policy: typing.Optional[typing.Union[CfnRule.RetryPolicyProperty, typing.Dict[builtins.str, typing.Any]]] = None,
         role: typing.Optional[_IRole_235f5d8e] = None,
         run_command_parameters: typing.Optional[typing.Union[CfnRule.RunCommandParametersProperty, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -10311,6 +10313,7 @@ class RuleTargetConfig:
         :param http_parameters: Contains the HTTP parameters to use when the target is a API Gateway REST endpoint or EventBridge API destination. Default: - None
         :param input: What input to send to the event target. Default: the entire event
         :param kinesis_parameters: Settings that control shard assignment, when the target is a Kinesis stream. If you don't include this parameter, eventId is used as the partition key.
+        :param redshift_data_parameters: Parameters used when the rule invokes Amazon Redshift Queries. Default: - no parameters set
         :param retry_policy: A RetryPolicy object that includes information about the retry policy settings. Default: EventBridge default retry policy
         :param role: Role to use to invoke this event target.
         :param run_command_parameters: Parameters used when the rule invokes Amazon EC2 Systems Manager Run Command.
@@ -10407,6 +10410,17 @@ class RuleTargetConfig:
                 kinesis_parameters=events.CfnRule.KinesisParametersProperty(
                     partition_key_path="partitionKeyPath"
                 ),
+                redshift_data_parameters=events.CfnRule.RedshiftDataParametersProperty(
+                    database="database",
+            
+                    # the properties below are optional
+                    db_user="dbUser",
+                    secret_manager_arn="secretManagerArn",
+                    sql="sql",
+                    sqls=["sqls"],
+                    statement_name="statementName",
+                    with_event=False
+                ),
                 retry_policy=events.CfnRule.RetryPolicyProperty(
                     maximum_event_age_in_seconds=123,
                     maximum_retry_attempts=123
@@ -10436,6 +10450,8 @@ class RuleTargetConfig:
             http_parameters = CfnRule.HttpParametersProperty(**http_parameters)
         if isinstance(kinesis_parameters, dict):
             kinesis_parameters = CfnRule.KinesisParametersProperty(**kinesis_parameters)
+        if isinstance(redshift_data_parameters, dict):
+            redshift_data_parameters = CfnRule.RedshiftDataParametersProperty(**redshift_data_parameters)
         if isinstance(retry_policy, dict):
             retry_policy = CfnRule.RetryPolicyProperty(**retry_policy)
         if isinstance(run_command_parameters, dict):
@@ -10452,6 +10468,7 @@ class RuleTargetConfig:
             check_type(argname="argument http_parameters", value=http_parameters, expected_type=type_hints["http_parameters"])
             check_type(argname="argument input", value=input, expected_type=type_hints["input"])
             check_type(argname="argument kinesis_parameters", value=kinesis_parameters, expected_type=type_hints["kinesis_parameters"])
+            check_type(argname="argument redshift_data_parameters", value=redshift_data_parameters, expected_type=type_hints["redshift_data_parameters"])
             check_type(argname="argument retry_policy", value=retry_policy, expected_type=type_hints["retry_policy"])
             check_type(argname="argument role", value=role, expected_type=type_hints["role"])
             check_type(argname="argument run_command_parameters", value=run_command_parameters, expected_type=type_hints["run_command_parameters"])
@@ -10474,6 +10491,8 @@ class RuleTargetConfig:
             self._values["input"] = input
         if kinesis_parameters is not None:
             self._values["kinesis_parameters"] = kinesis_parameters
+        if redshift_data_parameters is not None:
+            self._values["redshift_data_parameters"] = redshift_data_parameters
         if retry_policy is not None:
             self._values["retry_policy"] = retry_policy
         if role is not None:
@@ -10553,6 +10572,17 @@ class RuleTargetConfig:
         result = self._values.get("kinesis_parameters")
         return typing.cast(typing.Optional[CfnRule.KinesisParametersProperty], result)
 
+    @builtins.property
+    def redshift_data_parameters(
+        self,
+    ) -> typing.Optional[CfnRule.RedshiftDataParametersProperty]:
+        '''Parameters used when the rule invokes Amazon Redshift Queries.
+
+        :default: - no parameters set
+        '''
+        result = self._values.get("redshift_data_parameters")
+        return typing.cast(typing.Optional[CfnRule.RedshiftDataParametersProperty], result)
+
     @builtins.property
     def retry_policy(self) -> typing.Optional[CfnRule.RetryPolicyProperty]:
         '''A RetryPolicy object that includes information about the retry policy settings.
@@ -10862,27 +10892,22 @@ class Schedule(
 
     Example::
 
-        import aws_cdk.aws_ecs as ecs
+        import aws_cdk.aws_redshiftserverless as redshiftserverless
         
-        # cluster: ecs.ICluster
-        # task_definition: ecs.TaskDefinition
+        # workgroup: redshiftserverless.CfnWorkgroup
         
         
         rule = events.Rule(self, "Rule",
             schedule=events.Schedule.rate(cdk.Duration.hours(1))
         )
         
-        rule.add_target(
-            targets.EcsTask(
-                cluster=cluster,
-                task_definition=task_definition,
-                propagate_tags=ecs.PropagatedTagSource.TASK_DEFINITION,
-                tags=[targets.Tag(
-                    key="my-tag",
-                    value="my-tag-value"
-                )
-                ]
-            ))
+        dlq = sqs.Queue(self, "DeadLetterQueue")
+        
+        rule.add_target(targets.RedshiftQuery(workgroup.attr_workgroup_workgroup_arn,
+            database="dev",
+            dead_letter_queue=dlq,
+            sql=["SELECT * FROM foo", "SELECT * FROM baz"]
+        ))
     '''
 
     def __init__(self) -> None:
@@ -12891,6 +12916,7 @@ def _typecheckingstub__10b46a391417178d3d06a5360e56af2bf314e68a1662e39855324f124
     http_parameters: typing.Optional[typing.Union[CfnRule.HttpParametersProperty, typing.Dict[builtins.str, typing.Any]]] = None,
     input: typing.Optional[RuleTargetInput] = None,
     kinesis_parameters: typing.Optional[typing.Union[CfnRule.KinesisParametersProperty, typing.Dict[builtins.str, typing.Any]]] = None,
+    redshift_data_parameters: typing.Optional[typing.Union[CfnRule.RedshiftDataParametersProperty, typing.Dict[builtins.str, typing.Any]]] = None,
     retry_policy: typing.Optional[typing.Union[CfnRule.RetryPolicyProperty, typing.Dict[builtins.str, typing.Any]]] = None,
     role: typing.Optional[_IRole_235f5d8e] = None,
     run_command_parameters: typing.Optional[typing.Union[CfnRule.RunCommandParametersProperty, typing.Dict[builtins.str, typing.Any]]] = None,