aws-cdk-lib 2.114.0__py3-none-any.whl → 2.115.0__py3-none-any.whl

aws_cdk/aws_stepfunctions_tasks/__init__.py

@@ -35,6 +35,9 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
   * [Batch](#batch)
 
     * [SubmitJob](#submitjob)
+  * [Bedrock](#bedrock)
+
+    * [InvokeModel](#invokemodel)
   * [CodeBuild](#codebuild)
 
     * [StartBuild](#startbuild)
@@ -181,7 +184,7 @@ tasks.CallApiGatewayRestApiEndpoint(self, "Endpoint",
 The `CallApiGatewayHttpApiEndpoint` calls the HTTP API endpoint.
 
 ```python
-import aws_cdk.aws_apigatewayv2_alpha as apigatewayv2
+import aws_cdk.aws_apigatewayv2 as apigatewayv2
 
 http_api = apigatewayv2.HttpApi(self, "MyHttpApi")
 
@@ -327,6 +330,37 @@ task = tasks.BatchSubmitJob(self, "Submit Job",
 )
 ```
 
+## Bedrock
+
+Step Functions supports [Bedrock](https://docs.aws.amazon.com/step-functions/latest/dg/connect-bedrock.html) through the service integration pattern.
+
+### InvokeModel
+
+The [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) API
+invokes the specified Bedrock model to run inference using the input provided.
+The format of the input body and the response body depend on the model selected.
+
+```python
+import aws_cdk.aws_bedrock as bedrock
+
+
+model = bedrock.FoundationModel.from_foundation_model_id(self, "Model", bedrock.FoundationModelIdentifier.AMAZON_TITAN_TEXT_G1_EXPRESS_V1)
+
+task = tasks.BedrockInvokeModel(self, "Prompt Model",
+    model=model,
+    body=sfn.TaskInput.from_object({
+        "input_text": "Generate a list of five first names.",
+        "text_generation_config": {
+            "max_token_count": 100,
+            "temperature": 1
+        }
+    }),
+    result_selector={
+        "names": sfn.JsonPath.string_at("$.Body.results[0].outputText")
+    }
+)
+```
+
 ## CodeBuild
 
 Step Functions supports [CodeBuild](https://docs.aws.amazon.com/step-functions/latest/dg/connect-codebuild.html) through the service integration pattern.
@@ -640,6 +674,74 @@ tasks.EmrAddStep(self, "Task",
 )
 ```
 
+To specify a custom runtime role use the `executionRoleArn` property.
+
+**Note:** The EMR cluster must be created with a security configuration and the runtime role must have a specific trust policy.
+See this [blog post](https://aws.amazon.com/blogs/big-data/introducing-runtime-roles-for-amazon-emr-steps-use-iam-roles-and-aws-lake-formation-for-access-control-with-amazon-emr/) for more details.
+
+```python
+import aws_cdk.aws_emr as emr
+
+
+cfn_security_configuration = emr.CfnSecurityConfiguration(self, "EmrSecurityConfiguration",
+    name="AddStepRuntimeRoleSecConfig",
+    security_configuration=JSON.parse("""
+            {
+              "AuthorizationConfiguration": {
+                  "IAMConfiguration": {
+                      "EnableApplicationScopedIAMRole": true,
+                      "ApplicationScopedIAMRoleConfiguration":
+                          {
+                              "PropagateSourceIdentity": true
+                          }
+                  },
+                  "LakeFormationConfiguration": {
+                      "AuthorizedSessionTagValue": "Amazon EMR"
+                  }
+              }
+            }""")
+)
+
+task = tasks.EmrCreateCluster(self, "Create Cluster",
+    instances=tasks.EmrCreateCluster.InstancesConfigProperty(),
+    name=sfn.TaskInput.from_json_path_at("$.ClusterName").value,
+    security_configuration=cfn_security_configuration.name
+)
+
+execution_role = iam.Role(self, "Role",
+    assumed_by=iam.ArnPrincipal(task.cluster_role.role_arn)
+)
+
+execution_role.assume_role_policy.add_statements(
+    iam.PolicyStatement(
+        effect=iam.Effect.ALLOW,
+        principals=[task.cluster_role
+        ],
+        actions=["sts:SetSourceIdentity"
+        ]
+    ),
+    iam.PolicyStatement(
+        effect=iam.Effect.ALLOW,
+        principals=[task.cluster_role
+        ],
+        actions=["sts:TagSession"
+        ],
+        conditions={
+            "StringEquals": {
+                "aws:RequestTag/LakeFormationAuthorizedCaller": "Amazon EMR"
+            }
+        }
+    ))
+
+tasks.EmrAddStep(self, "Task",
+    cluster_id="ClusterId",
+    execution_role_arn=execution_role.role_arn,
+    name="StepName",
+    jar="Jar",
+    action_on_failure=tasks.ActionOnFailure.CONTINUE
+)
+```
+
 ### Cancel Step
 
 Cancels a pending step in a running cluster.
@@ -1365,6 +1467,7 @@ from .. import (
     SymlinkFollowMode as _SymlinkFollowMode_047ec1f6,
 )
 from ..aws_apigateway import IRestApi as _IRestApi_1f02523d
+from ..aws_bedrock import IModel as _IModel_b88b328a
 from ..aws_codebuild import (
     BuildEnvironmentVariable as _BuildEnvironmentVariable_7df4fa0c,
     IProject as _IProject_aafae30a,
@@ -3778,21 +3881,687 @@ class BatchSubmitJob(
             timeout=timeout,
         )
 
-        jsii.create(self.__class__, self, [scope, id, props])
+        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"))
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.BatchSubmitJobProps",
+    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",
+        "job_definition_arn": "jobDefinitionArn",
+        "job_name": "jobName",
+        "job_queue_arn": "jobQueueArn",
+        "array_size": "arraySize",
+        "attempts": "attempts",
+        "container_overrides": "containerOverrides",
+        "depends_on": "dependsOn",
+        "payload": "payload",
+        "tags": "tags",
+    },
+)
+class BatchSubmitJobProps(_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,
+        job_definition_arn: builtins.str,
+        job_name: builtins.str,
+        job_queue_arn: builtins.str,
+        array_size: typing.Optional[jsii.Number] = None,
+        attempts: typing.Optional[jsii.Number] = None,
+        container_overrides: typing.Optional[typing.Union[BatchContainerOverrides, typing.Dict[builtins.str, typing.Any]]] = None,
+        depends_on: typing.Optional[typing.Sequence[typing.Union[BatchJobDependency, typing.Dict[builtins.str, typing.Any]]]] = None,
+        payload: typing.Optional[_TaskInput_91b91b91] = None,
+        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    ) -> None:
+        '''Properties for RunBatchJob.
+
+        :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 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 job_definition_arn: The arn of the job definition used by this job.
+        :param job_name: The name of the job. The first character must be alphanumeric, and up to 128 letters (uppercase and lowercase), numbers, hyphens, and underscores are allowed.
+        :param job_queue_arn: The arn of the job queue into which the job is submitted.
+        :param array_size: The array size can be between 2 and 10,000. If you specify array properties for a job, it becomes an array job. For more information, see Array Jobs in the AWS Batch User Guide. Default: - No array size
+        :param attempts: The number of times to move a job to the RUNNABLE status. You may specify between 1 and 10 attempts. If the value of attempts is greater than one, the job is retried on failure the same number of attempts as the value. Default: 1
+        :param container_overrides: A list of container overrides in JSON format that specify the name of a container in the specified job definition and the overrides it should receive. Default: - No container overrides
+        :param depends_on: A list of dependencies for the job. A job can depend upon a maximum of 20 jobs. Default: - No dependencies
+        :param payload: The payload to be passed as parameters to the batch job. Default: - No parameters are passed
+        :param tags: The tags applied to the job request. Default: {} - no tags
+
+        :exampleMetadata: infused
+
+        Example::
+
+            import aws_cdk.aws_batch as batch
+            # batch_job_definition: batch.EcsJobDefinition
+            # batch_queue: batch.JobQueue
+            
+            
+            task = tasks.BatchSubmitJob(self, "Submit Job",
+                job_definition_arn=batch_job_definition.job_definition_arn,
+                job_name="MyJob",
+                job_queue_arn=batch_queue.job_queue_arn
+            )
+        '''
+        if isinstance(credentials, dict):
+            credentials = _Credentials_2cd64c6b(**credentials)
+        if isinstance(container_overrides, dict):
+            container_overrides = BatchContainerOverrides(**container_overrides)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__c3197d21dad4ba55e29e09cf770b47b7859167ae6b1ae5ef674cca1bedf86a92)
+            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 job_definition_arn", value=job_definition_arn, expected_type=type_hints["job_definition_arn"])
+            check_type(argname="argument job_name", value=job_name, expected_type=type_hints["job_name"])
+            check_type(argname="argument job_queue_arn", value=job_queue_arn, expected_type=type_hints["job_queue_arn"])
+            check_type(argname="argument array_size", value=array_size, expected_type=type_hints["array_size"])
+            check_type(argname="argument attempts", value=attempts, expected_type=type_hints["attempts"])
+            check_type(argname="argument container_overrides", value=container_overrides, expected_type=type_hints["container_overrides"])
+            check_type(argname="argument depends_on", value=depends_on, expected_type=type_hints["depends_on"])
+            check_type(argname="argument payload", value=payload, expected_type=type_hints["payload"])
+            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "job_definition_arn": job_definition_arn,
+            "job_name": job_name,
+            "job_queue_arn": job_queue_arn,
+        }
+        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 array_size is not None:
+            self._values["array_size"] = array_size
+        if attempts is not None:
+            self._values["attempts"] = attempts
+        if container_overrides is not None:
+            self._values["container_overrides"] = container_overrides
+        if depends_on is not None:
+            self._values["depends_on"] = depends_on
+        if payload is not None:
+            self._values["payload"] = payload
+        if tags is not None:
+            self._values["tags"] = tags
+
+    @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
+
+        :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-to-resource.html#connect-wait-token
+        '''
+        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 job_definition_arn(self) -> builtins.str:
+        '''The arn of the job definition used by this job.'''
+        result = self._values.get("job_definition_arn")
+        assert result is not None, "Required property 'job_definition_arn' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def job_name(self) -> builtins.str:
+        '''The name of the job.
+
+        The first character must be alphanumeric, and up to 128 letters (uppercase and lowercase),
+        numbers, hyphens, and underscores are allowed.
+        '''
+        result = self._values.get("job_name")
+        assert result is not None, "Required property 'job_name' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def job_queue_arn(self) -> builtins.str:
+        '''The arn of the job queue into which the job is submitted.'''
+        result = self._values.get("job_queue_arn")
+        assert result is not None, "Required property 'job_queue_arn' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def array_size(self) -> typing.Optional[jsii.Number]:
+        '''The array size can be between 2 and 10,000.
+
+        If you specify array properties for a job, it becomes an array job.
+        For more information, see Array Jobs in the AWS Batch User Guide.
+
+        :default: - No array size
+        '''
+        result = self._values.get("array_size")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def attempts(self) -> typing.Optional[jsii.Number]:
+        '''The number of times to move a job to the RUNNABLE status.
+
+        You may specify between 1 and 10 attempts.
+        If the value of attempts is greater than one,
+        the job is retried on failure the same number of attempts as the value.
+
+        :default: 1
+        '''
+        result = self._values.get("attempts")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def container_overrides(self) -> typing.Optional[BatchContainerOverrides]:
+        '''A list of container overrides in JSON format that specify the name of a container in the specified job definition and the overrides it should receive.
+
+        :default: - No container overrides
+
+        :see: https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html#Batch-SubmitJob-request-containerOverrides
+        '''
+        result = self._values.get("container_overrides")
+        return typing.cast(typing.Optional[BatchContainerOverrides], result)
+
+    @builtins.property
+    def depends_on(self) -> typing.Optional[typing.List[BatchJobDependency]]:
+        '''A list of dependencies for the job.
+
+        A job can depend upon a maximum of 20 jobs.
+
+        :default: - No dependencies
+
+        :see: https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html#Batch-SubmitJob-request-dependsOn
+        '''
+        result = self._values.get("depends_on")
+        return typing.cast(typing.Optional[typing.List[BatchJobDependency]], result)
+
+    @builtins.property
+    def payload(self) -> typing.Optional[_TaskInput_91b91b91]:
+        '''The payload to be passed as parameters to the batch job.
+
+        :default: - No parameters are passed
+        '''
+        result = self._values.get("payload")
+        return typing.cast(typing.Optional[_TaskInput_91b91b91], result)
+
+    @builtins.property
+    def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
+        '''The tags applied to the job request.
+
+        :default: {} - no tags
+        '''
+        result = self._values.get("tags")
+        return typing.cast(typing.Optional[typing.Mapping[builtins.str, 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 "BatchSubmitJobProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+class BedrockInvokeModel(
+    _TaskStateBase_b5c0a816,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.BedrockInvokeModel",
+):
+    '''A Step Functions Task to invoke a model in Bedrock.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        import aws_cdk.aws_bedrock as bedrock
+        
+        
+        model = bedrock.FoundationModel.from_foundation_model_id(self, "Model", bedrock.FoundationModelIdentifier.AMAZON_TITAN_TEXT_G1_EXPRESS_V1)
+        
+        task = tasks.BedrockInvokeModel(self, "Prompt Model",
+            model=model,
+            body=sfn.TaskInput.from_object({
+                "input_text": "Generate a list of five first names.",
+                "text_generation_config": {
+                    "max_token_count": 100,
+                    "temperature": 1
+                }
+            }),
+            result_selector={
+                "names": sfn.JsonPath.string_at("$.Body.results[0].outputText")
+            }
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        model: _IModel_b88b328a,
+        accept: typing.Optional[builtins.str] = None,
+        body: typing.Optional[_TaskInput_91b91b91] = None,
+        content_type: typing.Optional[builtins.str] = None,
+        input: typing.Optional[typing.Union["BedrockInvokeModelInputProps", typing.Dict[builtins.str, typing.Any]]] = None,
+        output: typing.Optional[typing.Union["BedrockInvokeModelOutputProps", typing.Dict[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 model: The Bedrock model that the task will invoke.
+        :param accept: The desired MIME type of the inference body in the response. Default: 'application/json'
+        :param body: The input data for the Bedrock model invocation. The inference parameters contained in the body depend on the Bedrock model being used. The body must be in the format specified in the ``contentType`` field. For example, if the content type is ``application/json``, the body must be JSON formatted. The body must be up to 256 KB in size. For input data that exceeds 256 KB, use ``input`` instead to retrieve the input data from S3. You must specify either the ``body`` or the ``input`` field, but not both. Default: Input data is retrieved from the location specified in the ``input`` field
+        :param content_type: The MIME type of the input data in the request. Default: 'application/json'
+        :param input: The source location to retrieve the input data from. Default: Input data is retrieved from the ``body`` field
+        :param output: The destination location where the API response is written. If you specify this field, the API response body is replaced with a reference to the output location. Default: The API response body is returned in the result.
+        :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 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__3b20c515efa874adacf78d373dbda10fc59e519a3bd1b280ecbf56409aea2544)
+            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 = BedrockInvokeModelProps(
+            model=model,
+            accept=accept,
+            body=body,
+            content_type=content_type,
+            input=input,
+            output=output,
+            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"))
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.BedrockInvokeModelInputProps",
+    jsii_struct_bases=[],
+    name_mapping={"s3_location": "s3Location"},
+)
+class BedrockInvokeModelInputProps:
+    def __init__(
+        self,
+        *,
+        s3_location: typing.Optional[typing.Union[_Location_0948fa7f, typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> None:
+        '''Location to retrieve the input data, prior to calling Bedrock InvokeModel.
+
+        :param s3_location: S3 object to retrieve the input data from. If the S3 location is not set, then the Body must be set. Default: Input data is retrieved from the ``body`` field
+
+        :see: https://docs.aws.amazon.com/step-functions/latest/dg/connect-bedrock.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_stepfunctions_tasks as stepfunctions_tasks
+            
+            bedrock_invoke_model_input_props = stepfunctions_tasks.BedrockInvokeModelInputProps(
+                s3_location=Location(
+                    bucket_name="bucketName",
+                    object_key="objectKey",
+            
+                    # the properties below are optional
+                    object_version="objectVersion"
+                )
+            )
+        '''
+        if isinstance(s3_location, dict):
+            s3_location = _Location_0948fa7f(**s3_location)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__5832c6287635fafcd3211864b6568285ae981df509ea5c6b8dd8458d0254c232)
+            check_type(argname="argument s3_location", value=s3_location, expected_type=type_hints["s3_location"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if s3_location is not None:
+            self._values["s3_location"] = s3_location
+
+    @builtins.property
+    def s3_location(self) -> typing.Optional[_Location_0948fa7f]:
+        '''S3 object to retrieve the input data from.
+
+        If the S3 location is not set, then the Body must be set.
+
+        :default: Input data is retrieved from the ``body`` field
+        '''
+        result = self._values.get("s3_location")
+        return typing.cast(typing.Optional[_Location_0948fa7f], 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 "BedrockInvokeModelInputProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.BedrockInvokeModelOutputProps",
+    jsii_struct_bases=[],
+    name_mapping={"s3_location": "s3Location"},
+)
+class BedrockInvokeModelOutputProps:
+    def __init__(
+        self,
+        *,
+        s3_location: typing.Optional[typing.Union[_Location_0948fa7f, typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> None:
+        '''Location where the Bedrock InvokeModel API response is written.
+
+        :param s3_location: S3 object where the Bedrock InvokeModel API response is written. If you specify this field, the API response body is replaced with a reference to the Amazon S3 location of the original output. Default: Response body is returned in the task result
 
-    @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"))
+        :see: https://docs.aws.amazon.com/step-functions/latest/dg/connect-bedrock.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_stepfunctions_tasks as stepfunctions_tasks
+            
+            bedrock_invoke_model_output_props = stepfunctions_tasks.BedrockInvokeModelOutputProps(
+                s3_location=Location(
+                    bucket_name="bucketName",
+                    object_key="objectKey",
+            
+                    # the properties below are optional
+                    object_version="objectVersion"
+                )
+            )
+        '''
+        if isinstance(s3_location, dict):
+            s3_location = _Location_0948fa7f(**s3_location)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__1ae5c9f4810ca6d7749a0e5f6df435956d3660251fb9427f7b8aea21bc5a7fb1)
+            check_type(argname="argument s3_location", value=s3_location, expected_type=type_hints["s3_location"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if s3_location is not None:
+            self._values["s3_location"] = s3_location
 
     @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 s3_location(self) -> typing.Optional[_Location_0948fa7f]:
+        '''S3 object where the Bedrock InvokeModel API response is written.
+
+        If you specify this field, the API response body is replaced with
+        a reference to the Amazon S3 location of the original output.
+
+        :default: Response body is returned in the task result
+        '''
+        result = self._values.get("s3_location")
+        return typing.cast(typing.Optional[_Location_0948fa7f], 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 "BedrockInvokeModelOutputProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
 
 
 @jsii.data_type(
-    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.BatchSubmitJobProps",
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.BedrockInvokeModelProps",
     jsii_struct_bases=[_TaskStateBaseProps_3a62b6d0],
     name_mapping={
         "comment": "comment",
@@ -3807,18 +4576,15 @@ class BatchSubmitJob(
         "state_name": "stateName",
         "task_timeout": "taskTimeout",
         "timeout": "timeout",
-        "job_definition_arn": "jobDefinitionArn",
-        "job_name": "jobName",
-        "job_queue_arn": "jobQueueArn",
-        "array_size": "arraySize",
-        "attempts": "attempts",
-        "container_overrides": "containerOverrides",
-        "depends_on": "dependsOn",
-        "payload": "payload",
-        "tags": "tags",
+        "model": "model",
+        "accept": "accept",
+        "body": "body",
+        "content_type": "contentType",
+        "input": "input",
+        "output": "output",
     },
 )
-class BatchSubmitJobProps(_TaskStateBaseProps_3a62b6d0):
+class BedrockInvokeModelProps(_TaskStateBaseProps_3a62b6d0):
     def __init__(
         self,
         *,
@@ -3834,17 +4600,14 @@ class BatchSubmitJobProps(_TaskStateBaseProps_3a62b6d0):
         state_name: typing.Optional[builtins.str] = None,
         task_timeout: typing.Optional[_Timeout_d7c10551] = None,
         timeout: typing.Optional[_Duration_4839e8c3] = None,
-        job_definition_arn: builtins.str,
-        job_name: builtins.str,
-        job_queue_arn: builtins.str,
-        array_size: typing.Optional[jsii.Number] = None,
-        attempts: typing.Optional[jsii.Number] = None,
-        container_overrides: typing.Optional[typing.Union[BatchContainerOverrides, typing.Dict[builtins.str, typing.Any]]] = None,
-        depends_on: typing.Optional[typing.Sequence[typing.Union[BatchJobDependency, typing.Dict[builtins.str, typing.Any]]]] = None,
-        payload: typing.Optional[_TaskInput_91b91b91] = None,
-        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        model: _IModel_b88b328a,
+        accept: typing.Optional[builtins.str] = None,
+        body: typing.Optional[_TaskInput_91b91b91] = None,
+        content_type: typing.Optional[builtins.str] = None,
+        input: typing.Optional[typing.Union[BedrockInvokeModelInputProps, typing.Dict[builtins.str, typing.Any]]] = None,
+        output: typing.Optional[typing.Union[BedrockInvokeModelOutputProps, typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
-        '''Properties for RunBatchJob.
+        '''Properties for invoking a Bedrock Model.
 
         :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)
@@ -3858,37 +4621,44 @@ class BatchSubmitJobProps(_TaskStateBaseProps_3a62b6d0):
         :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 job_definition_arn: The arn of the job definition used by this job.
-        :param job_name: The name of the job. The first character must be alphanumeric, and up to 128 letters (uppercase and lowercase), numbers, hyphens, and underscores are allowed.
-        :param job_queue_arn: The arn of the job queue into which the job is submitted.
-        :param array_size: The array size can be between 2 and 10,000. If you specify array properties for a job, it becomes an array job. For more information, see Array Jobs in the AWS Batch User Guide. Default: - No array size
-        :param attempts: The number of times to move a job to the RUNNABLE status. You may specify between 1 and 10 attempts. If the value of attempts is greater than one, the job is retried on failure the same number of attempts as the value. Default: 1
-        :param container_overrides: A list of container overrides in JSON format that specify the name of a container in the specified job definition and the overrides it should receive. Default: - No container overrides
-        :param depends_on: A list of dependencies for the job. A job can depend upon a maximum of 20 jobs. Default: - No dependencies
-        :param payload: The payload to be passed as parameters to the batch job. Default: - No parameters are passed
-        :param tags: The tags applied to the job request. Default: {} - no tags
+        :param model: The Bedrock model that the task will invoke.
+        :param accept: The desired MIME type of the inference body in the response. Default: 'application/json'
+        :param body: The input data for the Bedrock model invocation. The inference parameters contained in the body depend on the Bedrock model being used. The body must be in the format specified in the ``contentType`` field. For example, if the content type is ``application/json``, the body must be JSON formatted. The body must be up to 256 KB in size. For input data that exceeds 256 KB, use ``input`` instead to retrieve the input data from S3. You must specify either the ``body`` or the ``input`` field, but not both. Default: Input data is retrieved from the location specified in the ``input`` field
+        :param content_type: The MIME type of the input data in the request. Default: 'application/json'
+        :param input: The source location to retrieve the input data from. Default: Input data is retrieved from the ``body`` field
+        :param output: The destination location where the API response is written. If you specify this field, the API response body is replaced with a reference to the output location. Default: The API response body is returned in the result.
 
         :exampleMetadata: infused
 
         Example::
 
-            import aws_cdk.aws_batch as batch
-            # batch_job_definition: batch.EcsJobDefinition
-            # batch_queue: batch.JobQueue
+            import aws_cdk.aws_bedrock as bedrock
             
             
-            task = tasks.BatchSubmitJob(self, "Submit Job",
-                job_definition_arn=batch_job_definition.job_definition_arn,
-                job_name="MyJob",
-                job_queue_arn=batch_queue.job_queue_arn
+            model = bedrock.FoundationModel.from_foundation_model_id(self, "Model", bedrock.FoundationModelIdentifier.AMAZON_TITAN_TEXT_G1_EXPRESS_V1)
+            
+            task = tasks.BedrockInvokeModel(self, "Prompt Model",
+                model=model,
+                body=sfn.TaskInput.from_object({
+                    "input_text": "Generate a list of five first names.",
+                    "text_generation_config": {
+                        "max_token_count": 100,
+                        "temperature": 1
+                    }
+                }),
+                result_selector={
+                    "names": sfn.JsonPath.string_at("$.Body.results[0].outputText")
+                }
             )
         '''
         if isinstance(credentials, dict):
             credentials = _Credentials_2cd64c6b(**credentials)
-        if isinstance(container_overrides, dict):
-            container_overrides = BatchContainerOverrides(**container_overrides)
+        if isinstance(input, dict):
+            input = BedrockInvokeModelInputProps(**input)
+        if isinstance(output, dict):
+            output = BedrockInvokeModelOutputProps(**output)
         if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__c3197d21dad4ba55e29e09cf770b47b7859167ae6b1ae5ef674cca1bedf86a92)
+            type_hints = typing.get_type_hints(_typecheckingstub__a9bf54cbc3850dd1a65ada3b96e97b5e68b7027badd90592dbcc79a35d9b216e)
             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"])
@@ -3901,19 +4671,14 @@ class BatchSubmitJobProps(_TaskStateBaseProps_3a62b6d0):
             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 job_definition_arn", value=job_definition_arn, expected_type=type_hints["job_definition_arn"])
-            check_type(argname="argument job_name", value=job_name, expected_type=type_hints["job_name"])
-            check_type(argname="argument job_queue_arn", value=job_queue_arn, expected_type=type_hints["job_queue_arn"])
-            check_type(argname="argument array_size", value=array_size, expected_type=type_hints["array_size"])
-            check_type(argname="argument attempts", value=attempts, expected_type=type_hints["attempts"])
-            check_type(argname="argument container_overrides", value=container_overrides, expected_type=type_hints["container_overrides"])
-            check_type(argname="argument depends_on", value=depends_on, expected_type=type_hints["depends_on"])
-            check_type(argname="argument payload", value=payload, expected_type=type_hints["payload"])
-            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
+            check_type(argname="argument model", value=model, expected_type=type_hints["model"])
+            check_type(argname="argument accept", value=accept, expected_type=type_hints["accept"])
+            check_type(argname="argument body", value=body, expected_type=type_hints["body"])
+            check_type(argname="argument content_type", value=content_type, expected_type=type_hints["content_type"])
+            check_type(argname="argument input", value=input, expected_type=type_hints["input"])
+            check_type(argname="argument output", value=output, expected_type=type_hints["output"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
-            "job_definition_arn": job_definition_arn,
-            "job_name": job_name,
-            "job_queue_arn": job_queue_arn,
+            "model": model,
         }
         if comment is not None:
             self._values["comment"] = comment
@@ -3939,18 +4704,16 @@ class BatchSubmitJobProps(_TaskStateBaseProps_3a62b6d0):
             self._values["task_timeout"] = task_timeout
         if timeout is not None:
             self._values["timeout"] = timeout
-        if array_size is not None:
-            self._values["array_size"] = array_size
-        if attempts is not None:
-            self._values["attempts"] = attempts
-        if container_overrides is not None:
-            self._values["container_overrides"] = container_overrides
-        if depends_on is not None:
-            self._values["depends_on"] = depends_on
-        if payload is not None:
-            self._values["payload"] = payload
-        if tags is not None:
-            self._values["tags"] = tags
+        if accept is not None:
+            self._values["accept"] = accept
+        if body is not None:
+            self._values["body"] = body
+        if content_type is not None:
+            self._values["content_type"] = content_type
+        if input is not None:
+            self._values["input"] = input
+        if output is not None:
+            self._values["output"] = output
 
     @builtins.property
     def comment(self) -> typing.Optional[builtins.str]:
@@ -4106,96 +4869,79 @@ class BatchSubmitJobProps(_TaskStateBaseProps_3a62b6d0):
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
 
     @builtins.property
-    def job_definition_arn(self) -> builtins.str:
-        '''The arn of the job definition used by this job.'''
-        result = self._values.get("job_definition_arn")
-        assert result is not None, "Required property 'job_definition_arn' is missing"
-        return typing.cast(builtins.str, result)
-
-    @builtins.property
-    def job_name(self) -> builtins.str:
-        '''The name of the job.
+    def model(self) -> _IModel_b88b328a:
+        '''The Bedrock model that the task will invoke.
 
-        The first character must be alphanumeric, and up to 128 letters (uppercase and lowercase),
-        numbers, hyphens, and underscores are allowed.
+        :see: https://docs.aws.amazon.com/bedrock/latest/userguide/api-methods-run.html
         '''
-        result = self._values.get("job_name")
-        assert result is not None, "Required property 'job_name' is missing"
-        return typing.cast(builtins.str, result)
-
-    @builtins.property
-    def job_queue_arn(self) -> builtins.str:
-        '''The arn of the job queue into which the job is submitted.'''
-        result = self._values.get("job_queue_arn")
-        assert result is not None, "Required property 'job_queue_arn' is missing"
-        return typing.cast(builtins.str, result)
+        result = self._values.get("model")
+        assert result is not None, "Required property 'model' is missing"
+        return typing.cast(_IModel_b88b328a, result)
 
     @builtins.property
-    def array_size(self) -> typing.Optional[jsii.Number]:
-        '''The array size can be between 2 and 10,000.
+    def accept(self) -> typing.Optional[builtins.str]:
+        '''The desired MIME type of the inference body in the response.
 
-        If you specify array properties for a job, it becomes an array job.
-        For more information, see Array Jobs in the AWS Batch User Guide.
+        :default: 'application/json'
 
-        :default: - No array size
+        :see: https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html
         '''
-        result = self._values.get("array_size")
-        return typing.cast(typing.Optional[jsii.Number], result)
+        result = self._values.get("accept")
+        return typing.cast(typing.Optional[builtins.str], result)
 
     @builtins.property
-    def attempts(self) -> typing.Optional[jsii.Number]:
-        '''The number of times to move a job to the RUNNABLE status.
+    def body(self) -> typing.Optional[_TaskInput_91b91b91]:
+        '''The input data for the Bedrock model invocation.
 
-        You may specify between 1 and 10 attempts.
-        If the value of attempts is greater than one,
-        the job is retried on failure the same number of attempts as the value.
+        The inference parameters contained in the body depend on the Bedrock model being used.
 
-        :default: 1
-        '''
-        result = self._values.get("attempts")
-        return typing.cast(typing.Optional[jsii.Number], result)
+        The body must be in the format specified in the ``contentType`` field.
+        For example, if the content type is ``application/json``, the body must be
+        JSON formatted.
 
-    @builtins.property
-    def container_overrides(self) -> typing.Optional[BatchContainerOverrides]:
-        '''A list of container overrides in JSON format that specify the name of a container in the specified job definition and the overrides it should receive.
+        The body must be up to 256 KB in size. For input data that exceeds 256 KB,
+        use ``input`` instead to retrieve the input data from S3.
 
-        :default: - No container overrides
+        You must specify either the ``body`` or the ``input`` field, but not both.
 
-        :see: https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html#Batch-SubmitJob-request-containerOverrides
+        :default: Input data is retrieved from the location specified in the ``input`` field
+
+        :see: https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html
         '''
-        result = self._values.get("container_overrides")
-        return typing.cast(typing.Optional[BatchContainerOverrides], result)
+        result = self._values.get("body")
+        return typing.cast(typing.Optional[_TaskInput_91b91b91], result)
 
     @builtins.property
-    def depends_on(self) -> typing.Optional[typing.List[BatchJobDependency]]:
-        '''A list of dependencies for the job.
-
-        A job can depend upon a maximum of 20 jobs.
+    def content_type(self) -> typing.Optional[builtins.str]:
+        '''The MIME type of the input data in the request.
 
-        :default: - No dependencies
+        :default: 'application/json'
 
-        :see: https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html#Batch-SubmitJob-request-dependsOn
+        :see: https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html
         '''
-        result = self._values.get("depends_on")
-        return typing.cast(typing.Optional[typing.List[BatchJobDependency]], result)
+        result = self._values.get("content_type")
+        return typing.cast(typing.Optional[builtins.str], result)
 
     @builtins.property
-    def payload(self) -> typing.Optional[_TaskInput_91b91b91]:
-        '''The payload to be passed as parameters to the batch job.
+    def input(self) -> typing.Optional[BedrockInvokeModelInputProps]:
+        '''The source location to retrieve the input data from.
 
-        :default: - No parameters are passed
+        :default: Input data is retrieved from the ``body`` field
         '''
-        result = self._values.get("payload")
-        return typing.cast(typing.Optional[_TaskInput_91b91b91], result)
+        result = self._values.get("input")
+        return typing.cast(typing.Optional[BedrockInvokeModelInputProps], result)
 
     @builtins.property
-    def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
-        '''The tags applied to the job request.
+    def output(self) -> typing.Optional[BedrockInvokeModelOutputProps]:
+        '''The destination location where the API response is written.
 
-        :default: {} - no tags
+        If you specify this field, the API response body is replaced with a reference to the
+        output location.
+
+        :default: The API response body is returned in the result.
         '''
-        result = self._values.get("tags")
-        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
+        result = self._values.get("output")
+        return typing.cast(typing.Optional[BedrockInvokeModelOutputProps], result)
 
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
@@ -4204,7 +4950,7 @@ class BatchSubmitJobProps(_TaskStateBaseProps_3a62b6d0):
         return not (rhs == self)
 
     def __repr__(self) -> str:
-        return "BatchSubmitJobProps(%s)" % ", ".join(
+        return "BedrockInvokeModelProps(%s)" % ", ".join(
             k + "=" + repr(v) for k, v in self._values.items()
         )
 
@@ -4608,7 +5354,7 @@ class CallApiGatewayHttpApiEndpoint(
 
     Example::
 
-        import aws_cdk.aws_apigatewayv2_alpha as apigatewayv2
+        import aws_cdk.aws_apigatewayv2 as apigatewayv2
         
         http_api = apigatewayv2.HttpApi(self, "MyHttpApi")
         
@@ -4812,7 +5558,7 @@ class CallApiGatewayHttpApiEndpointProps(CallApiGatewayEndpointBaseProps):
 
         Example::
 
-            import aws_cdk.aws_apigatewayv2_alpha as apigatewayv2
+            import aws_cdk.aws_apigatewayv2 as apigatewayv2
             
             http_api = apigatewayv2.HttpApi(self, "MyHttpApi")
             
@@ -11599,6 +12345,7 @@ class EmrAddStep(
         name: builtins.str,
         action_on_failure: typing.Optional[ActionOnFailure] = None,
         args: typing.Optional[typing.Sequence[builtins.str]] = None,
+        execution_role_arn: typing.Optional[builtins.str] = None,
         main_class: typing.Optional[builtins.str] = None,
         properties: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         comment: typing.Optional[builtins.str] = None,
@@ -11622,6 +12369,7 @@ class EmrAddStep(
         :param name: The name of the Step.
         :param action_on_failure: The action to take when the cluster step fails. Default: ActionOnFailure.CONTINUE
         :param args: A list of command line arguments passed to the JAR file's main function when executed. Default: - No args
+        :param execution_role_arn: The Amazon Resource Name (ARN) of the runtime role for a step on the cluster. Default: - Uses EC2 instance profile role
         :param main_class: The name of the main class in the specified Java file. If not specified, the JAR file should specify a Main-Class in its manifest file. Default: - No mainClass
         :param properties: A list of Java properties that are set when the step runs. You can use these properties to pass key value pairs to your main function. Default: - No properties
         :param comment: An optional description for this state. Default: - No comment
@@ -11647,6 +12395,7 @@ class EmrAddStep(
             name=name,
             action_on_failure=action_on_failure,
             args=args,
+            execution_role_arn=execution_role_arn,
             main_class=main_class,
             properties=properties,
             comment=comment,
@@ -11697,6 +12446,7 @@ class EmrAddStep(
         "name": "name",
         "action_on_failure": "actionOnFailure",
         "args": "args",
+        "execution_role_arn": "executionRoleArn",
         "main_class": "mainClass",
         "properties": "properties",
     },
@@ -11722,6 +12472,7 @@ class EmrAddStepProps(_TaskStateBaseProps_3a62b6d0):
         name: builtins.str,
         action_on_failure: typing.Optional[ActionOnFailure] = None,
         args: typing.Optional[typing.Sequence[builtins.str]] = None,
+        execution_role_arn: typing.Optional[builtins.str] = None,
         main_class: typing.Optional[builtins.str] = None,
         properties: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
     ) -> None:
@@ -11744,6 +12495,7 @@ class EmrAddStepProps(_TaskStateBaseProps_3a62b6d0):
         :param name: The name of the Step.
         :param action_on_failure: The action to take when the cluster step fails. Default: ActionOnFailure.CONTINUE
         :param args: A list of command line arguments passed to the JAR file's main function when executed. Default: - No args
+        :param execution_role_arn: The Amazon Resource Name (ARN) of the runtime role for a step on the cluster. Default: - Uses EC2 instance profile role
         :param main_class: The name of the main class in the specified Java file. If not specified, the JAR file should specify a Main-Class in its manifest file. Default: - No mainClass
         :param properties: A list of Java properties that are set when the step runs. You can use these properties to pass key value pairs to your main function. Default: - No properties
 
@@ -11779,6 +12531,7 @@ class EmrAddStepProps(_TaskStateBaseProps_3a62b6d0):
             check_type(argname="argument name", value=name, expected_type=type_hints["name"])
             check_type(argname="argument action_on_failure", value=action_on_failure, expected_type=type_hints["action_on_failure"])
             check_type(argname="argument args", value=args, expected_type=type_hints["args"])
+            check_type(argname="argument execution_role_arn", value=execution_role_arn, expected_type=type_hints["execution_role_arn"])
             check_type(argname="argument main_class", value=main_class, expected_type=type_hints["main_class"])
             check_type(argname="argument properties", value=properties, expected_type=type_hints["properties"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
@@ -11814,6 +12567,8 @@ class EmrAddStepProps(_TaskStateBaseProps_3a62b6d0):
             self._values["action_on_failure"] = action_on_failure
         if args is not None:
             self._values["args"] = args
+        if execution_role_arn is not None:
+            self._values["execution_role_arn"] = execution_role_arn
         if main_class is not None:
             self._values["main_class"] = main_class
         if properties is not None:
@@ -12021,6 +12776,17 @@ class EmrAddStepProps(_TaskStateBaseProps_3a62b6d0):
         result = self._values.get("args")
         return typing.cast(typing.Optional[typing.List[builtins.str]], result)
 
+    @builtins.property
+    def execution_role_arn(self) -> typing.Optional[builtins.str]:
+        '''The Amazon Resource Name (ARN) of the runtime role for a step on the cluster.
+
+        :default: - Uses EC2 instance profile role
+
+        :see: https://docs.aws.amazon.com/emr/latest/APIReference/API_AddJobFlowSteps.html#API_AddJobFlowSteps_RequestSyntax
+        '''
+        result = self._values.get("execution_role_arn")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def main_class(self) -> typing.Optional[builtins.str]:
         '''The name of the main class in the specified Java file.
@@ -21312,7 +22078,7 @@ class HttpMethod(enum.Enum):
 
     Example::
 
-        import aws_cdk.aws_apigatewayv2_alpha as apigatewayv2
+        import aws_cdk.aws_apigatewayv2 as apigatewayv2
         
         http_api = apigatewayv2.HttpApi(self, "MyHttpApi")
         
@@ -29860,6 +30626,10 @@ __all__ = [
     "BatchStrategy",
     "BatchSubmitJob",
     "BatchSubmitJobProps",
+    "BedrockInvokeModel",
+    "BedrockInvokeModelInputProps",
+    "BedrockInvokeModelOutputProps",
+    "BedrockInvokeModelProps",
     "CallApiGatewayEndpointBaseProps",
     "CallApiGatewayHttpApiEndpoint",
     "CallApiGatewayHttpApiEndpointProps",
@@ -30290,6 +31060,70 @@ def _typecheckingstub__c3197d21dad4ba55e29e09cf770b47b7859167ae6b1ae5ef674cca1be
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__3b20c515efa874adacf78d373dbda10fc59e519a3bd1b280ecbf56409aea2544(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    model: _IModel_b88b328a,
+    accept: typing.Optional[builtins.str] = None,
+    body: typing.Optional[_TaskInput_91b91b91] = None,
+    content_type: typing.Optional[builtins.str] = None,
+    input: typing.Optional[typing.Union[BedrockInvokeModelInputProps, typing.Dict[builtins.str, typing.Any]]] = None,
+    output: typing.Optional[typing.Union[BedrockInvokeModelOutputProps, typing.Dict[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:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__5832c6287635fafcd3211864b6568285ae981df509ea5c6b8dd8458d0254c232(
+    *,
+    s3_location: typing.Optional[typing.Union[_Location_0948fa7f, typing.Dict[builtins.str, typing.Any]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__1ae5c9f4810ca6d7749a0e5f6df435956d3660251fb9427f7b8aea21bc5a7fb1(
+    *,
+    s3_location: typing.Optional[typing.Union[_Location_0948fa7f, typing.Dict[builtins.str, typing.Any]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__a9bf54cbc3850dd1a65ada3b96e97b5e68b7027badd90592dbcc79a35d9b216e(
+    *,
+    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,
+    model: _IModel_b88b328a,
+    accept: typing.Optional[builtins.str] = None,
+    body: typing.Optional[_TaskInput_91b91b91] = None,
+    content_type: typing.Optional[builtins.str] = None,
+    input: typing.Optional[typing.Union[BedrockInvokeModelInputProps, typing.Dict[builtins.str, typing.Any]]] = None,
+    output: typing.Optional[typing.Union[BedrockInvokeModelOutputProps, typing.Dict[builtins.str, typing.Any]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__e9dbc58cb4f9a28fbab12032a3c39bc929dcf76e35816fe9ba25aab36499c005(
     *,
     comment: typing.Optional[builtins.str] = None,
@@ -31116,6 +31950,7 @@ def _typecheckingstub__3889d4459b3d727348b867bd8b4b4db43cb1a83f081697d2504a78836
     name: builtins.str,
     action_on_failure: typing.Optional[ActionOnFailure] = None,
     args: typing.Optional[typing.Sequence[builtins.str]] = None,
+    execution_role_arn: typing.Optional[builtins.str] = None,
     main_class: typing.Optional[builtins.str] = None,
     properties: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
     comment: typing.Optional[builtins.str] = None,
@@ -31153,6 +31988,7 @@ def _typecheckingstub__16e8ce40cbe4d2af2daa80fd98236e2d21a2b602039be22115fc95da9
     name: builtins.str,
     action_on_failure: typing.Optional[ActionOnFailure] = None,
     args: typing.Optional[typing.Sequence[builtins.str]] = None,
+    execution_role_arn: typing.Optional[builtins.str] = None,
     main_class: typing.Optional[builtins.str] = None,
     properties: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
 ) -> None: