aws-cdk-lib 2.147.3__py3-none-any.whl → 2.148.1__py3-none-any.whl

aws_cdk/aws_stepfunctions_tasks/__init__.py

@@ -1,4 +1,4 @@
-'''
+r'''
 # Tasks for AWS Step Functions
 
 [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html) is a web service that enables you to coordinate the
@@ -25,7 +25,9 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
 
     * [Call REST API Endpoint](#call-rest-api-endpoint)
     * [Call HTTP API Endpoint](#call-http-api-endpoint)
-    * [AWS SDK](#aws-sdk)
+  * [AWS SDK](#aws-sdk)
+
+    * [Cross-region AWS API call](#cross-region-aws-api-call)
   * [Athena](#athena)
 
     * [StartQueryExecution](#startqueryexecution)
@@ -209,7 +211,7 @@ invoke_task = tasks.CallApiGatewayHttpApiEndpoint(self, "Call HTTP API",
 )
 ```
 
-### AWS SDK
+## AWS SDK
 
 Step Functions supports calling [AWS service's API actions](https://docs.aws.amazon.com/step-functions/latest/dg/supported-services-awssdk.html)
 through the service integration pattern.
@@ -266,6 +268,27 @@ detect_labels = tasks.CallAwsService(self, "DetectLabels",
 )
 ```
 
+### Cross-region AWS API call
+
+You can call AWS API in a different region from your state machine by using the `CallAwsServiceCrossRegion` construct. In addition to the properties for `CallAwsService` construct, you have to set `region` property to call the API.
+
+```python
+# my_bucket: s3.Bucket
+
+get_object = tasks.CallAwsServiceCrossRegion(self, "GetObject",
+    region="ap-northeast-1",
+    service="s3",
+    action="getObject",
+    parameters={
+        "Bucket": my_bucket.bucket_name,
+        "Key": sfn.JsonPath.string_at("$.key")
+    },
+    iam_resources=[my_bucket.arn_for_objects("*")]
+)
+```
+
+Other properties such as `additionalIamStatements` can be used in the same way as the `CallAwsService` task.
+
 ## Athena
 
 Step Functions supports [Athena](https://docs.aws.amazon.com/step-functions/latest/dg/connect-athena.html) through the service integration pattern.
@@ -6632,189 +6655,749 @@ class CallApiGatewayRestApiEndpointProps(CallApiGatewayEndpointBaseProps):
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
 
     @builtins.property
-    def method(self) -> "HttpMethod":
-        '''Http method for the API.'''
-        result = self._values.get("method")
-        assert result is not None, "Required property 'method' is missing"
-        return typing.cast("HttpMethod", result)
-
-    @builtins.property
-    def api_path(self) -> typing.Optional[builtins.str]:
-        '''Path parameters appended after API endpoint.
+    def method(self) -> "HttpMethod":
+        '''Http method for the API.'''
+        result = self._values.get("method")
+        assert result is not None, "Required property 'method' is missing"
+        return typing.cast("HttpMethod", result)
+
+    @builtins.property
+    def api_path(self) -> typing.Optional[builtins.str]:
+        '''Path parameters appended after API endpoint.
+
+        :default: - No path
+        '''
+        result = self._values.get("api_path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def auth_type(self) -> typing.Optional[AuthType]:
+        '''Authentication methods.
+
+        :default: AuthType.NO_AUTH
+        '''
+        result = self._values.get("auth_type")
+        return typing.cast(typing.Optional[AuthType], result)
+
+    @builtins.property
+    def headers(self) -> typing.Optional[_TaskInput_91b91b91]:
+        '''HTTP request information that does not relate to contents of the request.
+
+        :default: - No headers
+        '''
+        result = self._values.get("headers")
+        return typing.cast(typing.Optional[_TaskInput_91b91b91], result)
+
+    @builtins.property
+    def query_parameters(self) -> typing.Optional[_TaskInput_91b91b91]:
+        '''Query strings attatched to end of request.
+
+        :default: - No query parameters
+        '''
+        result = self._values.get("query_parameters")
+        return typing.cast(typing.Optional[_TaskInput_91b91b91], result)
+
+    @builtins.property
+    def request_body(self) -> typing.Optional[_TaskInput_91b91b91]:
+        '''HTTP Request body.
+
+        :default: - No request body
+        '''
+        result = self._values.get("request_body")
+        return typing.cast(typing.Optional[_TaskInput_91b91b91], result)
+
+    @builtins.property
+    def api(self) -> _IRestApi_1f02523d:
+        '''API to call.'''
+        result = self._values.get("api")
+        assert result is not None, "Required property 'api' is missing"
+        return typing.cast(_IRestApi_1f02523d, result)
+
+    @builtins.property
+    def stage_name(self) -> builtins.str:
+        '''Name of the stage where the API is deployed to in API Gateway.'''
+        result = self._values.get("stage_name")
+        assert result is not None, "Required property 'stage_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 "CallApiGatewayRestApiEndpointProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+class CallAwsService(
+    _TaskStateBase_b5c0a816,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.CallAwsService",
+):
+    '''A StepFunctions task to call an AWS service API.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        # my_bucket: s3.Bucket
+        
+        get_object = tasks.CallAwsService(self, "GetObject",
+            service="s3",
+            action="getObject",
+            parameters={
+                "Bucket": my_bucket.bucket_name,
+                "Key": sfn.JsonPath.string_at("$.key")
+            },
+            iam_resources=[my_bucket.arn_for_objects("*")]
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        action: builtins.str,
+        iam_resources: typing.Sequence[builtins.str],
+        service: builtins.str,
+        additional_iam_statements: typing.Optional[typing.Sequence[_PolicyStatement_0fe33853]] = None,
+        iam_action: typing.Optional[builtins.str] = None,
+        parameters: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+        comment: typing.Optional[builtins.str] = None,
+        credentials: typing.Optional[typing.Union[_Credentials_2cd64c6b, typing.Dict[builtins.str, typing.Any]]] = None,
+        heartbeat: typing.Optional[_Duration_4839e8c3] = None,
+        heartbeat_timeout: typing.Optional[_Timeout_d7c10551] = None,
+        input_path: typing.Optional[builtins.str] = None,
+        integration_pattern: typing.Optional[_IntegrationPattern_949291bc] = None,
+        output_path: typing.Optional[builtins.str] = None,
+        result_path: typing.Optional[builtins.str] = None,
+        result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+        state_name: typing.Optional[builtins.str] = None,
+        task_timeout: typing.Optional[_Timeout_d7c10551] = None,
+        timeout: typing.Optional[_Duration_4839e8c3] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param id: Descriptive identifier for this chainable.
+        :param action: The API action to call. Use camelCase.
+        :param iam_resources: The resources for the IAM statement that will be added to the state machine role's policy to allow the state machine to make the API call. By default the action for this IAM statement will be ``service:action``.
+        :param service: The AWS service to call.
+        :param additional_iam_statements: Additional IAM statements that will be added to the state machine role's policy. Use in the case where the call requires more than a single statement to be executed, e.g. ``rekognition:detectLabels`` requires also S3 permissions to read the object on which it must act. Default: - no additional statements are added
+        :param iam_action: The action for the IAM statement that will be added to the state machine role's policy to allow the state machine to make the API call. Use in the case where the IAM action name does not match with the API service/action name, e.g. ``s3:ListBuckets`` requires ``s3:ListAllMyBuckets``. Default: - service:action
+        :param parameters: Parameters for the API action call. Use PascalCase for the parameter names. Default: - no parameters
+        :param comment: An optional description for this state. Default: - No comment
+        :param credentials: Credentials for an IAM Role that the State Machine assumes for executing the task. This enables cross-account resource invocations. Default: - None (Task is executed using the State Machine's execution role)
+        :param heartbeat: (deprecated) Timeout for the heartbeat. Default: - None
+        :param heartbeat_timeout: Timeout for the heartbeat. [disable-awslint:duration-prop-type] is needed because all props interface in aws-stepfunctions-tasks extend this interface Default: - None
+        :param input_path: JSONPath expression to select part of the state to be the input to this state. May also be the special value JsonPath.DISCARD, which will cause the effective input to be the empty object {}. Default: - The entire task input (JSON path '$')
+        :param integration_pattern: AWS Step Functions integrates with services directly in the Amazon States Language. You can control these AWS services using service integration patterns. Depending on the AWS Service, the Service Integration Pattern availability will vary. Default: - ``IntegrationPattern.REQUEST_RESPONSE`` for most tasks. ``IntegrationPattern.RUN_JOB`` for the following exceptions: ``BatchSubmitJob``, ``EmrAddStep``, ``EmrCreateCluster``, ``EmrTerminationCluster``, and ``EmrContainersStartJobRun``.
+        :param output_path: JSONPath expression to select select a portion of the state output to pass to the next state. May also be the special value JsonPath.DISCARD, which will cause the effective output to be the empty object {}. Default: - The entire JSON node determined by the state input, the task result, and resultPath is passed to the next state (JSON path '$')
+        :param result_path: JSONPath expression to indicate where to inject the state's output. May also be the special value JsonPath.DISCARD, which will cause the state's input to become its output. Default: - Replaces the entire input with the result (JSON path '$')
+        :param result_selector: The JSON that will replace the state's raw result and become the effective result before ResultPath is applied. You can use ResultSelector to create a payload with values that are static or selected from the state's raw result. Default: - None
+        :param state_name: Optional name for this state. Default: - The construct ID will be used as state name
+        :param task_timeout: Timeout for the task. [disable-awslint:duration-prop-type] is needed because all props interface in aws-stepfunctions-tasks extend this interface Default: - None
+        :param timeout: (deprecated) Timeout for the task. Default: - None
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__e4534f8232f0840d6ef9dc3920130b2d24934f22c4483b9bd14a19e8152f0b6f)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = CallAwsServiceProps(
+            action=action,
+            iam_resources=iam_resources,
+            service=service,
+            additional_iam_statements=additional_iam_statements,
+            iam_action=iam_action,
+            parameters=parameters,
+            comment=comment,
+            credentials=credentials,
+            heartbeat=heartbeat,
+            heartbeat_timeout=heartbeat_timeout,
+            input_path=input_path,
+            integration_pattern=integration_pattern,
+            output_path=output_path,
+            result_path=result_path,
+            result_selector=result_selector,
+            state_name=state_name,
+            task_timeout=task_timeout,
+            timeout=timeout,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @builtins.property
+    @jsii.member(jsii_name="taskMetrics")
+    def _task_metrics(self) -> typing.Optional[_TaskMetricsConfig_32ea9403]:
+        return typing.cast(typing.Optional[_TaskMetricsConfig_32ea9403], jsii.get(self, "taskMetrics"))
+
+    @builtins.property
+    @jsii.member(jsii_name="taskPolicies")
+    def _task_policies(self) -> typing.Optional[typing.List[_PolicyStatement_0fe33853]]:
+        return typing.cast(typing.Optional[typing.List[_PolicyStatement_0fe33853]], jsii.get(self, "taskPolicies"))
+
+
+class CallAwsServiceCrossRegion(
+    _TaskStateBase_b5c0a816,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.CallAwsServiceCrossRegion",
+):
+    '''A Step Functions task to call an AWS service API across regions.
+
+    This task creates a Lambda function to call cross-region AWS API and invokes it.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        # my_bucket: s3.Bucket
+        
+        get_object = tasks.CallAwsServiceCrossRegion(self, "GetObject",
+            region="ap-northeast-1",
+            service="s3",
+            action="getObject",
+            parameters={
+                "Bucket": my_bucket.bucket_name,
+                "Key": sfn.JsonPath.string_at("$.key")
+            },
+            iam_resources=[my_bucket.arn_for_objects("*")]
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        action: builtins.str,
+        iam_resources: typing.Sequence[builtins.str],
+        region: builtins.str,
+        service: builtins.str,
+        additional_iam_statements: typing.Optional[typing.Sequence[_PolicyStatement_0fe33853]] = None,
+        endpoint: typing.Optional[builtins.str] = None,
+        iam_action: typing.Optional[builtins.str] = None,
+        parameters: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+        retry_on_service_exceptions: typing.Optional[builtins.bool] = None,
+        comment: typing.Optional[builtins.str] = None,
+        credentials: typing.Optional[typing.Union[_Credentials_2cd64c6b, typing.Dict[builtins.str, typing.Any]]] = None,
+        heartbeat: typing.Optional[_Duration_4839e8c3] = None,
+        heartbeat_timeout: typing.Optional[_Timeout_d7c10551] = None,
+        input_path: typing.Optional[builtins.str] = None,
+        integration_pattern: typing.Optional[_IntegrationPattern_949291bc] = None,
+        output_path: typing.Optional[builtins.str] = None,
+        result_path: typing.Optional[builtins.str] = None,
+        result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+        state_name: typing.Optional[builtins.str] = None,
+        task_timeout: typing.Optional[_Timeout_d7c10551] = None,
+        timeout: typing.Optional[_Duration_4839e8c3] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param id: Descriptive identifier for this chainable.
+        :param action: The API action to call. Use camelCase.
+        :param iam_resources: The resources for the IAM statement that will be added to the Lambda function role's policy to allow the state machine to make the API call.
+        :param region: The AWS region to call this AWS API for.
+        :param service: The AWS service to call in AWS SDK for JavaScript v3 style.
+        :param additional_iam_statements: Additional IAM statements that will be added to the state machine role's policy. Use in the case where the call requires more than a single statement to be executed, e.g. ``rekognition:detectLabels`` requires also S3 permissions to read the object on which it must act. Default: - no additional statements are added
+        :param endpoint: The AWS API endpoint. Default: Do not override API endpoint.
+        :param iam_action: The action for the IAM statement that will be added to the Lambda function role's policy to allow the state machine to make the API call. By default the action for this IAM statement will be ``service:action``. Use in the case where the IAM action name does not match with the API service/action name, e.g. ``s3:ListBuckets`` requires ``s3:ListAllMyBuckets``. Default: - service:action
+        :param parameters: Parameters for the API action call. Use PascalCase for the parameter names. Default: - no parameters
+        :param retry_on_service_exceptions: Whether to retry on the backend Lambda service exceptions. This handles ``Lambda.ServiceException``, ``Lambda.AWSLambdaException``, ``Lambda.SdkClientException``, and ``Lambda.ClientExecutionTimeoutException`` with an interval of 2 seconds, a back-off rate of 2 and 6 maximum attempts. Default: true
+        :param comment: An optional description for this state. Default: - No comment
+        :param credentials: Credentials for an IAM Role that the State Machine assumes for executing the task. This enables cross-account resource invocations. Default: - None (Task is executed using the State Machine's execution role)
+        :param heartbeat: (deprecated) Timeout for the heartbeat. Default: - None
+        :param heartbeat_timeout: Timeout for the heartbeat. [disable-awslint:duration-prop-type] is needed because all props interface in aws-stepfunctions-tasks extend this interface Default: - None
+        :param input_path: JSONPath expression to select part of the state to be the input to this state. May also be the special value JsonPath.DISCARD, which will cause the effective input to be the empty object {}. Default: - The entire task input (JSON path '$')
+        :param integration_pattern: AWS Step Functions integrates with services directly in the Amazon States Language. You can control these AWS services using service integration patterns. Depending on the AWS Service, the Service Integration Pattern availability will vary. Default: - ``IntegrationPattern.REQUEST_RESPONSE`` for most tasks. ``IntegrationPattern.RUN_JOB`` for the following exceptions: ``BatchSubmitJob``, ``EmrAddStep``, ``EmrCreateCluster``, ``EmrTerminationCluster``, and ``EmrContainersStartJobRun``.
+        :param output_path: JSONPath expression to select select a portion of the state output to pass to the next state. May also be the special value JsonPath.DISCARD, which will cause the effective output to be the empty object {}. Default: - The entire JSON node determined by the state input, the task result, and resultPath is passed to the next state (JSON path '$')
+        :param result_path: JSONPath expression to indicate where to inject the state's output. May also be the special value JsonPath.DISCARD, which will cause the state's input to become its output. Default: - Replaces the entire input with the result (JSON path '$')
+        :param result_selector: The JSON that will replace the state's raw result and become the effective result before ResultPath is applied. You can use ResultSelector to create a payload with values that are static or selected from the state's raw result. Default: - None
+        :param state_name: Optional name for this state. Default: - The construct ID will be used as state name
+        :param task_timeout: Timeout for the task. [disable-awslint:duration-prop-type] is needed because all props interface in aws-stepfunctions-tasks extend this interface Default: - None
+        :param timeout: (deprecated) Timeout for the task. Default: - None
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__788d4ab0ebc83fedbcaa927c3a9c9a8e1a7299ac43edcd72cc49a907a5b183b1)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = CallAwsServiceCrossRegionProps(
+            action=action,
+            iam_resources=iam_resources,
+            region=region,
+            service=service,
+            additional_iam_statements=additional_iam_statements,
+            endpoint=endpoint,
+            iam_action=iam_action,
+            parameters=parameters,
+            retry_on_service_exceptions=retry_on_service_exceptions,
+            comment=comment,
+            credentials=credentials,
+            heartbeat=heartbeat,
+            heartbeat_timeout=heartbeat_timeout,
+            input_path=input_path,
+            integration_pattern=integration_pattern,
+            output_path=output_path,
+            result_path=result_path,
+            result_selector=result_selector,
+            state_name=state_name,
+            task_timeout=task_timeout,
+            timeout=timeout,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @builtins.property
+    @jsii.member(jsii_name="lambdaFunction")
+    def _lambda_function(self) -> _IFunction_6adb0ab8:
+        return typing.cast(_IFunction_6adb0ab8, jsii.get(self, "lambdaFunction"))
+
+    @builtins.property
+    @jsii.member(jsii_name="taskMetrics")
+    def _task_metrics(self) -> typing.Optional[_TaskMetricsConfig_32ea9403]:
+        return typing.cast(typing.Optional[_TaskMetricsConfig_32ea9403], jsii.get(self, "taskMetrics"))
+
+    @builtins.property
+    @jsii.member(jsii_name="taskPolicies")
+    def _task_policies(self) -> typing.Optional[typing.List[_PolicyStatement_0fe33853]]:
+        return typing.cast(typing.Optional[typing.List[_PolicyStatement_0fe33853]], jsii.get(self, "taskPolicies"))
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.CallAwsServiceCrossRegionProps",
+    jsii_struct_bases=[_TaskStateBaseProps_3a62b6d0],
+    name_mapping={
+        "comment": "comment",
+        "credentials": "credentials",
+        "heartbeat": "heartbeat",
+        "heartbeat_timeout": "heartbeatTimeout",
+        "input_path": "inputPath",
+        "integration_pattern": "integrationPattern",
+        "output_path": "outputPath",
+        "result_path": "resultPath",
+        "result_selector": "resultSelector",
+        "state_name": "stateName",
+        "task_timeout": "taskTimeout",
+        "timeout": "timeout",
+        "action": "action",
+        "iam_resources": "iamResources",
+        "region": "region",
+        "service": "service",
+        "additional_iam_statements": "additionalIamStatements",
+        "endpoint": "endpoint",
+        "iam_action": "iamAction",
+        "parameters": "parameters",
+        "retry_on_service_exceptions": "retryOnServiceExceptions",
+    },
+)
+class CallAwsServiceCrossRegionProps(_TaskStateBaseProps_3a62b6d0):
+    def __init__(
+        self,
+        *,
+        comment: typing.Optional[builtins.str] = None,
+        credentials: typing.Optional[typing.Union[_Credentials_2cd64c6b, typing.Dict[builtins.str, typing.Any]]] = None,
+        heartbeat: typing.Optional[_Duration_4839e8c3] = None,
+        heartbeat_timeout: typing.Optional[_Timeout_d7c10551] = None,
+        input_path: typing.Optional[builtins.str] = None,
+        integration_pattern: typing.Optional[_IntegrationPattern_949291bc] = None,
+        output_path: typing.Optional[builtins.str] = None,
+        result_path: typing.Optional[builtins.str] = None,
+        result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+        state_name: typing.Optional[builtins.str] = None,
+        task_timeout: typing.Optional[_Timeout_d7c10551] = None,
+        timeout: typing.Optional[_Duration_4839e8c3] = None,
+        action: builtins.str,
+        iam_resources: typing.Sequence[builtins.str],
+        region: builtins.str,
+        service: builtins.str,
+        additional_iam_statements: typing.Optional[typing.Sequence[_PolicyStatement_0fe33853]] = None,
+        endpoint: typing.Optional[builtins.str] = None,
+        iam_action: typing.Optional[builtins.str] = None,
+        parameters: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+        retry_on_service_exceptions: typing.Optional[builtins.bool] = None,
+    ) -> None:
+        '''Properties for calling an AWS service's API action from your state machine across regions.
+
+        :param comment: An optional description for this state. Default: - No comment
+        :param credentials: Credentials for an IAM Role that the State Machine assumes for executing the task. This enables cross-account resource invocations. Default: - None (Task is executed using the State Machine's execution role)
+        :param heartbeat: (deprecated) Timeout for the heartbeat. Default: - None
+        :param heartbeat_timeout: Timeout for the heartbeat. [disable-awslint:duration-prop-type] is needed because all props interface in aws-stepfunctions-tasks extend this interface Default: - None
+        :param input_path: JSONPath expression to select part of the state to be the input to this state. May also be the special value JsonPath.DISCARD, which will cause the effective input to be the empty object {}. Default: - The entire task input (JSON path '$')
+        :param integration_pattern: AWS Step Functions integrates with services directly in the Amazon States Language. You can control these AWS services using service integration patterns. Depending on the AWS Service, the Service Integration Pattern availability will vary. Default: - ``IntegrationPattern.REQUEST_RESPONSE`` for most tasks. ``IntegrationPattern.RUN_JOB`` for the following exceptions: ``BatchSubmitJob``, ``EmrAddStep``, ``EmrCreateCluster``, ``EmrTerminationCluster``, and ``EmrContainersStartJobRun``.
+        :param output_path: JSONPath expression to select select a portion of the state output to pass to the next state. May also be the special value JsonPath.DISCARD, which will cause the effective output to be the empty object {}. Default: - The entire JSON node determined by the state input, the task result, and resultPath is passed to the next state (JSON path '$')
+        :param result_path: JSONPath expression to indicate where to inject the state's output. May also be the special value JsonPath.DISCARD, which will cause the state's input to become its output. Default: - Replaces the entire input with the result (JSON path '$')
+        :param result_selector: The JSON that will replace the state's raw result and become the effective result before ResultPath is applied. You can use ResultSelector to create a payload with values that are static or selected from the state's raw result. Default: - None
+        :param state_name: Optional name for this state. Default: - The construct ID will be used as state name
+        :param task_timeout: Timeout for the task. [disable-awslint:duration-prop-type] is needed because all props interface in aws-stepfunctions-tasks extend this interface Default: - None
+        :param timeout: (deprecated) Timeout for the task. Default: - None
+        :param action: The API action to call. Use camelCase.
+        :param iam_resources: The resources for the IAM statement that will be added to the Lambda function role's policy to allow the state machine to make the API call.
+        :param region: The AWS region to call this AWS API for.
+        :param service: The AWS service to call in AWS SDK for JavaScript v3 style.
+        :param additional_iam_statements: Additional IAM statements that will be added to the state machine role's policy. Use in the case where the call requires more than a single statement to be executed, e.g. ``rekognition:detectLabels`` requires also S3 permissions to read the object on which it must act. Default: - no additional statements are added
+        :param endpoint: The AWS API endpoint. Default: Do not override API endpoint.
+        :param iam_action: The action for the IAM statement that will be added to the Lambda function role's policy to allow the state machine to make the API call. By default the action for this IAM statement will be ``service:action``. Use in the case where the IAM action name does not match with the API service/action name, e.g. ``s3:ListBuckets`` requires ``s3:ListAllMyBuckets``. Default: - service:action
+        :param parameters: Parameters for the API action call. Use PascalCase for the parameter names. Default: - no parameters
+        :param retry_on_service_exceptions: Whether to retry on the backend Lambda service exceptions. This handles ``Lambda.ServiceException``, ``Lambda.AWSLambdaException``, ``Lambda.SdkClientException``, and ``Lambda.ClientExecutionTimeoutException`` with an interval of 2 seconds, a back-off rate of 2 and 6 maximum attempts. Default: true
+
+        :exampleMetadata: infused
+
+        Example::
+
+            # my_bucket: s3.Bucket
+            
+            get_object = tasks.CallAwsServiceCrossRegion(self, "GetObject",
+                region="ap-northeast-1",
+                service="s3",
+                action="getObject",
+                parameters={
+                    "Bucket": my_bucket.bucket_name,
+                    "Key": sfn.JsonPath.string_at("$.key")
+                },
+                iam_resources=[my_bucket.arn_for_objects("*")]
+            )
+        '''
+        if isinstance(credentials, dict):
+            credentials = _Credentials_2cd64c6b(**credentials)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__992363fbcea98bcb2c2657a6b897b7392fc6dc4d41155241ad7622bdc9d61923)
+            check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
+            check_type(argname="argument credentials", value=credentials, expected_type=type_hints["credentials"])
+            check_type(argname="argument heartbeat", value=heartbeat, expected_type=type_hints["heartbeat"])
+            check_type(argname="argument heartbeat_timeout", value=heartbeat_timeout, expected_type=type_hints["heartbeat_timeout"])
+            check_type(argname="argument input_path", value=input_path, expected_type=type_hints["input_path"])
+            check_type(argname="argument integration_pattern", value=integration_pattern, expected_type=type_hints["integration_pattern"])
+            check_type(argname="argument output_path", value=output_path, expected_type=type_hints["output_path"])
+            check_type(argname="argument result_path", value=result_path, expected_type=type_hints["result_path"])
+            check_type(argname="argument result_selector", value=result_selector, expected_type=type_hints["result_selector"])
+            check_type(argname="argument state_name", value=state_name, expected_type=type_hints["state_name"])
+            check_type(argname="argument task_timeout", value=task_timeout, expected_type=type_hints["task_timeout"])
+            check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
+            check_type(argname="argument action", value=action, expected_type=type_hints["action"])
+            check_type(argname="argument iam_resources", value=iam_resources, expected_type=type_hints["iam_resources"])
+            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
+            check_type(argname="argument service", value=service, expected_type=type_hints["service"])
+            check_type(argname="argument additional_iam_statements", value=additional_iam_statements, expected_type=type_hints["additional_iam_statements"])
+            check_type(argname="argument endpoint", value=endpoint, expected_type=type_hints["endpoint"])
+            check_type(argname="argument iam_action", value=iam_action, expected_type=type_hints["iam_action"])
+            check_type(argname="argument parameters", value=parameters, expected_type=type_hints["parameters"])
+            check_type(argname="argument retry_on_service_exceptions", value=retry_on_service_exceptions, expected_type=type_hints["retry_on_service_exceptions"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "action": action,
+            "iam_resources": iam_resources,
+            "region": region,
+            "service": service,
+        }
+        if comment is not None:
+            self._values["comment"] = comment
+        if credentials is not None:
+            self._values["credentials"] = credentials
+        if heartbeat is not None:
+            self._values["heartbeat"] = heartbeat
+        if heartbeat_timeout is not None:
+            self._values["heartbeat_timeout"] = heartbeat_timeout
+        if input_path is not None:
+            self._values["input_path"] = input_path
+        if integration_pattern is not None:
+            self._values["integration_pattern"] = integration_pattern
+        if output_path is not None:
+            self._values["output_path"] = output_path
+        if result_path is not None:
+            self._values["result_path"] = result_path
+        if result_selector is not None:
+            self._values["result_selector"] = result_selector
+        if state_name is not None:
+            self._values["state_name"] = state_name
+        if task_timeout is not None:
+            self._values["task_timeout"] = task_timeout
+        if timeout is not None:
+            self._values["timeout"] = timeout
+        if additional_iam_statements is not None:
+            self._values["additional_iam_statements"] = additional_iam_statements
+        if endpoint is not None:
+            self._values["endpoint"] = endpoint
+        if iam_action is not None:
+            self._values["iam_action"] = iam_action
+        if parameters is not None:
+            self._values["parameters"] = parameters
+        if retry_on_service_exceptions is not None:
+            self._values["retry_on_service_exceptions"] = retry_on_service_exceptions
+
+    @builtins.property
+    def comment(self) -> typing.Optional[builtins.str]:
+        '''An optional description for this state.
+
+        :default: - No comment
+        '''
+        result = self._values.get("comment")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def credentials(self) -> typing.Optional[_Credentials_2cd64c6b]:
+        '''Credentials for an IAM Role that the State Machine assumes for executing the task.
+
+        This enables cross-account resource invocations.
+
+        :default: - None (Task is executed using the State Machine's execution role)
+
+        :see: https://docs.aws.amazon.com/step-functions/latest/dg/concepts-access-cross-acct-resources.html
+        '''
+        result = self._values.get("credentials")
+        return typing.cast(typing.Optional[_Credentials_2cd64c6b], result)
+
+    @builtins.property
+    def heartbeat(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''(deprecated) Timeout for the heartbeat.
+
+        :default: - None
+
+        :deprecated: use ``heartbeatTimeout``
+
+        :stability: deprecated
+        '''
+        result = self._values.get("heartbeat")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
+    @builtins.property
+    def heartbeat_timeout(self) -> typing.Optional[_Timeout_d7c10551]:
+        '''Timeout for the heartbeat.
+
+        [disable-awslint:duration-prop-type] is needed because all props interface in
+        aws-stepfunctions-tasks extend this interface
+
+        :default: - None
+        '''
+        result = self._values.get("heartbeat_timeout")
+        return typing.cast(typing.Optional[_Timeout_d7c10551], result)
+
+    @builtins.property
+    def input_path(self) -> typing.Optional[builtins.str]:
+        '''JSONPath expression to select part of the state to be the input to this state.
+
+        May also be the special value JsonPath.DISCARD, which will cause the effective
+        input to be the empty object {}.
+
+        :default: - The entire task input (JSON path '$')
+        '''
+        result = self._values.get("input_path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def integration_pattern(self) -> typing.Optional[_IntegrationPattern_949291bc]:
+        '''AWS Step Functions integrates with services directly in the Amazon States Language.
+
+        You can control these AWS services using service integration patterns.
+
+        Depending on the AWS Service, the Service Integration Pattern availability will vary.
+
+        :default:
+
+        - ``IntegrationPattern.REQUEST_RESPONSE`` for most tasks.
+        ``IntegrationPattern.RUN_JOB`` for the following exceptions:
+        ``BatchSubmitJob``, ``EmrAddStep``, ``EmrCreateCluster``, ``EmrTerminationCluster``, and ``EmrContainersStartJobRun``.
+
+        :see: https://docs.aws.amazon.com/step-functions/latest/dg/connect-supported-services.html
+        '''
+        result = self._values.get("integration_pattern")
+        return typing.cast(typing.Optional[_IntegrationPattern_949291bc], result)
+
+    @builtins.property
+    def output_path(self) -> typing.Optional[builtins.str]:
+        '''JSONPath expression to select select a portion of the state output to pass to the next state.
+
+        May also be the special value JsonPath.DISCARD, which will cause the effective
+        output to be the empty object {}.
+
+        :default:
+
+        - The entire JSON node determined by the state input, the task result,
+        and resultPath is passed to the next state (JSON path '$')
+        '''
+        result = self._values.get("output_path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def result_path(self) -> typing.Optional[builtins.str]:
+        '''JSONPath expression to indicate where to inject the state's output.
+
+        May also be the special value JsonPath.DISCARD, which will cause the state's
+        input to become its output.
+
+        :default: - Replaces the entire input with the result (JSON path '$')
+        '''
+        result = self._values.get("result_path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def result_selector(
+        self,
+    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
+        '''The JSON that will replace the state's raw result and become the effective result before ResultPath is applied.
+
+        You can use ResultSelector to create a payload with values that are static
+        or selected from the state's raw result.
+
+        :default: - None
+
+        :see: https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-resultselector
+        '''
+        result = self._values.get("result_selector")
+        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)
+
+    @builtins.property
+    def state_name(self) -> typing.Optional[builtins.str]:
+        '''Optional name for this state.
+
+        :default: - The construct ID will be used as state name
+        '''
+        result = self._values.get("state_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def task_timeout(self) -> typing.Optional[_Timeout_d7c10551]:
+        '''Timeout for the task.
+
+        [disable-awslint:duration-prop-type] is needed because all props interface in
+        aws-stepfunctions-tasks extend this interface
+
+        :default: - None
+        '''
+        result = self._values.get("task_timeout")
+        return typing.cast(typing.Optional[_Timeout_d7c10551], result)
+
+    @builtins.property
+    def timeout(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''(deprecated) Timeout for the task.
+
+        :default: - None
+
+        :deprecated: use ``taskTimeout``
+
+        :stability: deprecated
+        '''
+        result = self._values.get("timeout")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
+    @builtins.property
+    def action(self) -> builtins.str:
+        '''The API action to call.
 
-        :default: - No path
+        Use camelCase.
         '''
-        result = self._values.get("api_path")
-        return typing.cast(typing.Optional[builtins.str], result)
+        result = self._values.get("action")
+        assert result is not None, "Required property 'action' is missing"
+        return typing.cast(builtins.str, result)
 
     @builtins.property
-    def auth_type(self) -> typing.Optional[AuthType]:
-        '''Authentication methods.
+    def iam_resources(self) -> typing.List[builtins.str]:
+        '''The resources for the IAM statement that will be added to the Lambda function role's policy to allow the state machine to make the API call.'''
+        result = self._values.get("iam_resources")
+        assert result is not None, "Required property 'iam_resources' is missing"
+        return typing.cast(typing.List[builtins.str], result)
 
-        :default: AuthType.NO_AUTH
+    @builtins.property
+    def region(self) -> builtins.str:
+        '''The AWS region to call this AWS API for.
+
+        Example::
+
+            "us-east-1"
         '''
-        result = self._values.get("auth_type")
-        return typing.cast(typing.Optional[AuthType], result)
+        result = self._values.get("region")
+        assert result is not None, "Required property 'region' is missing"
+        return typing.cast(builtins.str, result)
 
     @builtins.property
-    def headers(self) -> typing.Optional[_TaskInput_91b91b91]:
-        '''HTTP request information that does not relate to contents of the request.
+    def service(self) -> builtins.str:
+        '''The AWS service to call in AWS SDK for JavaScript v3 style.
 
-        :default: - No headers
+        :see: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/
+
+        Example::
+
+            "s3"
         '''
-        result = self._values.get("headers")
-        return typing.cast(typing.Optional[_TaskInput_91b91b91], result)
+        result = self._values.get("service")
+        assert result is not None, "Required property 'service' is missing"
+        return typing.cast(builtins.str, result)
 
     @builtins.property
-    def query_parameters(self) -> typing.Optional[_TaskInput_91b91b91]:
-        '''Query strings attatched to end of request.
+    def additional_iam_statements(
+        self,
+    ) -> typing.Optional[typing.List[_PolicyStatement_0fe33853]]:
+        '''Additional IAM statements that will be added to the state machine role's policy.
 
-        :default: - No query parameters
+        Use in the case where the call requires more than a single statement to
+        be executed, e.g. ``rekognition:detectLabels`` requires also S3 permissions
+        to read the object on which it must act.
+
+        :default: - no additional statements are added
         '''
-        result = self._values.get("query_parameters")
-        return typing.cast(typing.Optional[_TaskInput_91b91b91], result)
+        result = self._values.get("additional_iam_statements")
+        return typing.cast(typing.Optional[typing.List[_PolicyStatement_0fe33853]], result)
 
     @builtins.property
-    def request_body(self) -> typing.Optional[_TaskInput_91b91b91]:
-        '''HTTP Request body.
+    def endpoint(self) -> typing.Optional[builtins.str]:
+        '''The AWS API endpoint.
 
-        :default: - No request body
+        :default: Do not override API endpoint.
         '''
-        result = self._values.get("request_body")
-        return typing.cast(typing.Optional[_TaskInput_91b91b91], result)
+        result = self._values.get("endpoint")
+        return typing.cast(typing.Optional[builtins.str], result)
 
     @builtins.property
-    def api(self) -> _IRestApi_1f02523d:
-        '''API to call.'''
-        result = self._values.get("api")
-        assert result is not None, "Required property 'api' is missing"
-        return typing.cast(_IRestApi_1f02523d, result)
+    def iam_action(self) -> typing.Optional[builtins.str]:
+        '''The action for the IAM statement that will be added to the Lambda function role's policy to allow the state machine to make the API call.
 
-    @builtins.property
-    def stage_name(self) -> builtins.str:
-        '''Name of the stage where the API is deployed to in API Gateway.'''
-        result = self._values.get("stage_name")
-        assert result is not None, "Required property 'stage_name' is missing"
-        return typing.cast(builtins.str, result)
+        By default the action for this IAM statement will be ``service:action``.
 
-    def __eq__(self, rhs: typing.Any) -> builtins.bool:
-        return isinstance(rhs, self.__class__) and rhs._values == self._values
+        Use in the case where the IAM action name does not match with the
+        API service/action name, e.g. ``s3:ListBuckets`` requires ``s3:ListAllMyBuckets``.
 
-    def __ne__(self, rhs: typing.Any) -> builtins.bool:
-        return not (rhs == self)
+        :default: - service:action
+        '''
+        result = self._values.get("iam_action")
+        return typing.cast(typing.Optional[builtins.str], result)
 
-    def __repr__(self) -> str:
-        return "CallApiGatewayRestApiEndpointProps(%s)" % ", ".join(
-            k + "=" + repr(v) for k, v in self._values.items()
-        )
+    @builtins.property
+    def parameters(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
+        '''Parameters for the API action call.
 
+        Use PascalCase for the parameter names.
 
-class CallAwsService(
-    _TaskStateBase_b5c0a816,
-    metaclass=jsii.JSIIMeta,
-    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.CallAwsService",
-):
-    '''A StepFunctions task to call an AWS service API.
+        :default: - no parameters
+        '''
+        result = self._values.get("parameters")
+        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)
 
-    :exampleMetadata: infused
+    @builtins.property
+    def retry_on_service_exceptions(self) -> typing.Optional[builtins.bool]:
+        '''Whether to retry on the backend Lambda service exceptions.
 
-    Example::
+        This handles ``Lambda.ServiceException``, ``Lambda.AWSLambdaException``,
+        ``Lambda.SdkClientException``, and ``Lambda.ClientExecutionTimeoutException``
+        with an interval of 2 seconds, a back-off rate
+        of 2 and 6 maximum attempts.
 
-        # my_bucket: s3.Bucket
-        
-        get_object = tasks.CallAwsService(self, "GetObject",
-            service="s3",
-            action="getObject",
-            parameters={
-                "Bucket": my_bucket.bucket_name,
-                "Key": sfn.JsonPath.string_at("$.key")
-            },
-            iam_resources=[my_bucket.arn_for_objects("*")]
-        )
-    '''
+        :default: true
 
-    def __init__(
-        self,
-        scope: _constructs_77d1e7e8.Construct,
-        id: builtins.str,
-        *,
-        action: builtins.str,
-        iam_resources: typing.Sequence[builtins.str],
-        service: builtins.str,
-        additional_iam_statements: typing.Optional[typing.Sequence[_PolicyStatement_0fe33853]] = None,
-        iam_action: typing.Optional[builtins.str] = None,
-        parameters: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
-        comment: typing.Optional[builtins.str] = None,
-        credentials: typing.Optional[typing.Union[_Credentials_2cd64c6b, typing.Dict[builtins.str, typing.Any]]] = None,
-        heartbeat: typing.Optional[_Duration_4839e8c3] = None,
-        heartbeat_timeout: typing.Optional[_Timeout_d7c10551] = None,
-        input_path: typing.Optional[builtins.str] = None,
-        integration_pattern: typing.Optional[_IntegrationPattern_949291bc] = None,
-        output_path: typing.Optional[builtins.str] = None,
-        result_path: typing.Optional[builtins.str] = None,
-        result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
-        state_name: typing.Optional[builtins.str] = None,
-        task_timeout: typing.Optional[_Timeout_d7c10551] = None,
-        timeout: typing.Optional[_Duration_4839e8c3] = None,
-    ) -> None:
-        '''
-        :param scope: -
-        :param id: Descriptive identifier for this chainable.
-        :param action: The API action to call. Use camelCase.
-        :param iam_resources: The resources for the IAM statement that will be added to the state machine role's policy to allow the state machine to make the API call. By default the action for this IAM statement will be ``service:action``.
-        :param service: The AWS service to call.
-        :param additional_iam_statements: Additional IAM statements that will be added to the state machine role's policy. Use in the case where the call requires more than a single statement to be executed, e.g. ``rekognition:detectLabels`` requires also S3 permissions to read the object on which it must act. Default: - no additional statements are added
-        :param iam_action: The action for the IAM statement that will be added to the state machine role's policy to allow the state machine to make the API call. Use in the case where the IAM action name does not match with the API service/action name, e.g. ``s3:ListBuckets`` requires ``s3:ListAllMyBuckets``. Default: - service:action
-        :param parameters: Parameters for the API action call. Use PascalCase for the parameter names. Default: - no parameters
-        :param comment: An optional description for this state. Default: - No comment
-        :param credentials: Credentials for an IAM Role that the State Machine assumes for executing the task. This enables cross-account resource invocations. Default: - None (Task is executed using the State Machine's execution role)
-        :param heartbeat: (deprecated) Timeout for the heartbeat. Default: - None
-        :param heartbeat_timeout: Timeout for the heartbeat. [disable-awslint:duration-prop-type] is needed because all props interface in aws-stepfunctions-tasks extend this interface Default: - None
-        :param input_path: JSONPath expression to select part of the state to be the input to this state. May also be the special value JsonPath.DISCARD, which will cause the effective input to be the empty object {}. Default: - The entire task input (JSON path '$')
-        :param integration_pattern: AWS Step Functions integrates with services directly in the Amazon States Language. You can control these AWS services using service integration patterns. Depending on the AWS Service, the Service Integration Pattern availability will vary. Default: - ``IntegrationPattern.REQUEST_RESPONSE`` for most tasks. ``IntegrationPattern.RUN_JOB`` for the following exceptions: ``BatchSubmitJob``, ``EmrAddStep``, ``EmrCreateCluster``, ``EmrTerminationCluster``, and ``EmrContainersStartJobRun``.
-        :param output_path: JSONPath expression to select select a portion of the state output to pass to the next state. May also be the special value JsonPath.DISCARD, which will cause the effective output to be the empty object {}. Default: - The entire JSON node determined by the state input, the task result, and resultPath is passed to the next state (JSON path '$')
-        :param result_path: JSONPath expression to indicate where to inject the state's output. May also be the special value JsonPath.DISCARD, which will cause the state's input to become its output. Default: - Replaces the entire input with the result (JSON path '$')
-        :param result_selector: The JSON that will replace the state's raw result and become the effective result before ResultPath is applied. You can use ResultSelector to create a payload with values that are static or selected from the state's raw result. Default: - None
-        :param state_name: Optional name for this state. Default: - The construct ID will be used as state name
-        :param task_timeout: Timeout for the task. [disable-awslint:duration-prop-type] is needed because all props interface in aws-stepfunctions-tasks extend this interface Default: - None
-        :param timeout: (deprecated) Timeout for the task. Default: - None
+        :see: https://docs.aws.amazon.com/step-functions/latest/dg/bp-lambda-serviceexception.html
         '''
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__e4534f8232f0840d6ef9dc3920130b2d24934f22c4483b9bd14a19e8152f0b6f)
-            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
-            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
-        props = CallAwsServiceProps(
-            action=action,
-            iam_resources=iam_resources,
-            service=service,
-            additional_iam_statements=additional_iam_statements,
-            iam_action=iam_action,
-            parameters=parameters,
-            comment=comment,
-            credentials=credentials,
-            heartbeat=heartbeat,
-            heartbeat_timeout=heartbeat_timeout,
-            input_path=input_path,
-            integration_pattern=integration_pattern,
-            output_path=output_path,
-            result_path=result_path,
-            result_selector=result_selector,
-            state_name=state_name,
-            task_timeout=task_timeout,
-            timeout=timeout,
-        )
+        result = self._values.get("retry_on_service_exceptions")
+        return typing.cast(typing.Optional[builtins.bool], result)
 
-        jsii.create(self.__class__, self, [scope, id, props])
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
 
-    @builtins.property
-    @jsii.member(jsii_name="taskMetrics")
-    def _task_metrics(self) -> typing.Optional[_TaskMetricsConfig_32ea9403]:
-        return typing.cast(typing.Optional[_TaskMetricsConfig_32ea9403], jsii.get(self, "taskMetrics"))
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
 
-    @builtins.property
-    @jsii.member(jsii_name="taskPolicies")
-    def _task_policies(self) -> typing.Optional[typing.List[_PolicyStatement_0fe33853]]:
-        return typing.cast(typing.Optional[typing.List[_PolicyStatement_0fe33853]], jsii.get(self, "taskPolicies"))
+    def __repr__(self) -> str:
+        return "CallAwsServiceCrossRegionProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
 
 
 @jsii.data_type(
@@ -33441,6 +34024,8 @@ __all__ = [
     "CallApiGatewayRestApiEndpoint",
     "CallApiGatewayRestApiEndpointProps",
     "CallAwsService",
+    "CallAwsServiceCrossRegion",
+    "CallAwsServiceCrossRegionProps",
     "CallAwsServiceProps",
     "Channel",
     "Classification",
@@ -34101,6 +34686,62 @@ def _typecheckingstub__e4534f8232f0840d6ef9dc3920130b2d24934f22c4483b9bd14a19e81
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__788d4ab0ebc83fedbcaa927c3a9c9a8e1a7299ac43edcd72cc49a907a5b183b1(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    action: builtins.str,
+    iam_resources: typing.Sequence[builtins.str],
+    region: builtins.str,
+    service: builtins.str,
+    additional_iam_statements: typing.Optional[typing.Sequence[_PolicyStatement_0fe33853]] = None,
+    endpoint: typing.Optional[builtins.str] = None,
+    iam_action: typing.Optional[builtins.str] = None,
+    parameters: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+    retry_on_service_exceptions: typing.Optional[builtins.bool] = None,
+    comment: typing.Optional[builtins.str] = None,
+    credentials: typing.Optional[typing.Union[_Credentials_2cd64c6b, typing.Dict[builtins.str, typing.Any]]] = None,
+    heartbeat: typing.Optional[_Duration_4839e8c3] = None,
+    heartbeat_timeout: typing.Optional[_Timeout_d7c10551] = None,
+    input_path: typing.Optional[builtins.str] = None,
+    integration_pattern: typing.Optional[_IntegrationPattern_949291bc] = None,
+    output_path: typing.Optional[builtins.str] = None,
+    result_path: typing.Optional[builtins.str] = None,
+    result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+    state_name: typing.Optional[builtins.str] = None,
+    task_timeout: typing.Optional[_Timeout_d7c10551] = None,
+    timeout: typing.Optional[_Duration_4839e8c3] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__992363fbcea98bcb2c2657a6b897b7392fc6dc4d41155241ad7622bdc9d61923(
+    *,
+    comment: typing.Optional[builtins.str] = None,
+    credentials: typing.Optional[typing.Union[_Credentials_2cd64c6b, typing.Dict[builtins.str, typing.Any]]] = None,
+    heartbeat: typing.Optional[_Duration_4839e8c3] = None,
+    heartbeat_timeout: typing.Optional[_Timeout_d7c10551] = None,
+    input_path: typing.Optional[builtins.str] = None,
+    integration_pattern: typing.Optional[_IntegrationPattern_949291bc] = None,
+    output_path: typing.Optional[builtins.str] = None,
+    result_path: typing.Optional[builtins.str] = None,
+    result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+    state_name: typing.Optional[builtins.str] = None,
+    task_timeout: typing.Optional[_Timeout_d7c10551] = None,
+    timeout: typing.Optional[_Duration_4839e8c3] = None,
+    action: builtins.str,
+    iam_resources: typing.Sequence[builtins.str],
+    region: builtins.str,
+    service: builtins.str,
+    additional_iam_statements: typing.Optional[typing.Sequence[_PolicyStatement_0fe33853]] = None,
+    endpoint: typing.Optional[builtins.str] = None,
+    iam_action: typing.Optional[builtins.str] = None,
+    parameters: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+    retry_on_service_exceptions: typing.Optional[builtins.bool] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__63c577047b5ec17a682dc869c299af67611178c845f52baceb7e79927eee3db3(
     *,
     comment: typing.Optional[builtins.str] = None,