aws-cdk-lib 2.195.0__py3-none-any.whl → 2.224.0__py3-none-any.whl

aws_cdk/aws_stepfunctions_tasks/__init__.py

@@ -40,9 +40,13 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
   * [Bedrock](#bedrock)
 
     * [InvokeModel](#invokemodel)
+    * [Using Input Path for S3 URI](#using-input-path-for-s3-uri)
+    * [Using Input Path](#using-input-path)
+    * [createModelCustomizationJob](#createmodelcustomizationjob)
   * [CodeBuild](#codebuild)
 
     * [StartBuild](#startbuild)
+    * [StartBuildBatch](#startbuildbatch)
   * [DynamoDB](#dynamodb)
 
     * [GetItem](#getitem)
@@ -55,6 +59,8 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
 
       * [EC2](#ec2)
       * [Fargate](#fargate)
+      * [Override CPU and Memory Parameter](#override-cpu-and-memory-parameter)
+      * [ECS enable Exec](#ecs-enable-exec)
   * [EMR](#emr)
 
     * [Create Cluster](#create-cluster)
@@ -75,19 +81,23 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
   * [EventBridge](#eventbridge)
 
     * [Put Events](#put-events)
+  * [EventBridge Scheduler](#eventbridge-scheduler)
+
+    * [Create Scheduler](#create-scheduler)
   * [Glue](#glue)
 
-    * [Start Job Run](#start-job-run)
-    * [Start Crawler Run](#startcrawlerrun)
+    * [StartJobRun](#startjobrun)
+    * [StartCrawlerRun](#startcrawlerrun)
   * [Glue DataBrew](#glue-databrew)
 
     * [Start Job Run](#start-job-run-1)
+  * [Invoke HTTP API](#invoke-http-api)
   * [Lambda](#lambda)
 
     * [Invoke](#invoke)
   * [MediaConvert](#mediaconvert)
 
-    * [Create Job](#create-job)
+    * [CreateJob](#createjob)
   * [SageMaker](#sagemaker)
 
     * [Create Training Job](#create-training-job)
@@ -151,6 +161,17 @@ The `EvaluateExpression` supports a `runtime` prop to specify the Lambda
 runtime to use to evaluate the expression. Currently, only runtimes
 of the Node.js family are supported.
 
+The `EvaluateExpression` also supports an `architecture` prop to specify the Lambda
+architecture. This can be useful when migrating to ARM64 or when running integration
+tests on ARM64 systems.
+
+```python
+convert_to_seconds_arm64 = tasks.EvaluateExpression(self, "Convert to seconds",
+    expression="$.waitMilliseconds / 1000",
+    architecture=lambda_.Architecture.ARM_64
+)
+```
+
 ## API Gateway
 
 Step Functions supports [API Gateway](https://docs.aws.amazon.com/step-functions/latest/dg/connect-api-gateway.html) through the service integration pattern.
@@ -510,6 +531,56 @@ task = tasks.BedrockInvokeModel(self, "Prompt Model with guardrail",
 )
 ```
 
+### createModelCustomizationJob
+
+The [CreateModelCustomizationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateModelCustomizationJob.html) API creates a fine-tuning job to customize a base model.
+
+```python
+import aws_cdk.aws_bedrock as bedrock
+import aws_cdk.aws_kms as kms
+
+# output_bucket: s3.IBucket
+# training_bucket: s3.IBucket
+# validation_bucket: s3.IBucket
+# kms_key: kms.IKey
+# vpc: ec2.IVpc
+
+
+model = bedrock.FoundationModel.from_foundation_model_id(self, "Model", bedrock.FoundationModelIdentifier.AMAZON_TITAN_TEXT_G1_EXPRESS_V1)
+
+task = tasks.BedrockCreateModelCustomizationJob(self, "CreateModelCustomizationJob",
+    base_model=model,
+    client_request_token="MyToken",
+    customization_type=tasks.CustomizationType.FINE_TUNING,
+    custom_model_kms_key=kms_key,
+    custom_model_name="MyCustomModel",  # required
+    custom_model_tags=[tasks.CustomModelTag(key="key1", value="value1")],
+    hyper_parameters={
+        "batch_size": "10"
+    },
+    job_name="MyCustomizationJob",  # required
+    job_tags=[tasks.CustomModelTag(key="key2", value="value2")],
+    output_data=tasks.OutputBucketConfiguration(
+        bucket=output_bucket,  # required
+        path="output-data/"
+    ),
+    training_data=tasks.TrainingBucketConfiguration(
+        bucket=training_bucket,
+        path="training-data/data.json"
+    ),  # required
+    # If you don't provide validation data, you have to specify `Evaluation percentage` hyperparameter.
+    validation_data=[tasks.ValidationBucketConfiguration(
+        bucket=validation_bucket,
+        path="validation-data/data.json"
+    )
+    ],
+    vpc_config={
+        "security_groups": [ec2.SecurityGroup(self, "SecurityGroup", vpc=vpc)],
+        "subnets": vpc.private_subnets
+    }
+)
+```
+
 ## CodeBuild
 
 Step Functions supports [CodeBuild](https://docs.aws.amazon.com/step-functions/latest/dg/connect-codebuild.html) through the service integration pattern.
@@ -906,6 +977,18 @@ tasks.EmrCreateCluster(self, "SpotSpecification",
 )
 ```
 
+You can [customize EBS root device volume](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-custom-ami-root-volume-size.html).
+
+```python
+tasks.EmrCreateCluster(self, "Create Cluster",
+    instances=tasks.EmrCreateCluster.InstancesConfigProperty(),
+    name="ClusterName",
+    ebs_root_volume_iops=4000,
+    ebs_root_volume_size=Size.gibibytes(20),
+    ebs_root_volume_throughput=200
+)
+```
+
 If you want to run multiple steps in [parallel](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-concurrent-steps.html),
 you can specify the `stepConcurrencyLevel` property. The concurrency range is between 1
 and 256 inclusive, where the default concurrency of 1 means no step concurrency is allowed.
@@ -931,6 +1014,43 @@ tasks.EmrCreateCluster(self, "Create Cluster",
 )
 ```
 
+If you want to use [managed scaling](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-managed-scaling.html),
+you can specify the `managedScalingPolicy` property.
+
+```python
+tasks.EmrCreateCluster(self, "CreateCluster",
+    instances=tasks.EmrCreateCluster.InstancesConfigProperty(
+        instance_fleets=[tasks.EmrCreateCluster.InstanceFleetConfigProperty(
+            instance_fleet_type=tasks.EmrCreateCluster.InstanceRoleType.CORE,
+            instance_type_configs=[tasks.EmrCreateCluster.InstanceTypeConfigProperty(
+                instance_type="m5.xlarge"
+            )
+            ],
+            target_on_demand_capacity=1
+        ), tasks.EmrCreateCluster.InstanceFleetConfigProperty(
+            instance_fleet_type=tasks.EmrCreateCluster.InstanceRoleType.MASTER,
+            instance_type_configs=[tasks.EmrCreateCluster.InstanceTypeConfigProperty(
+                instance_type="m5.xlarge"
+            )
+            ],
+            target_on_demand_capacity=1
+        )
+        ]
+    ),
+    name="ClusterName",
+    release_label="emr-7.9.0",
+    managed_scaling_policy=tasks.EmrCreateCluster.ManagedScalingPolicyProperty(
+        compute_limits=tasks.EmrCreateCluster.ManagedScalingComputeLimitsProperty(
+            unit_type=tasks.EmrCreateCluster.ComputeLimitsUnitType.INSTANCE_FLEET_UNITS,
+            maximum_capacity_units=4,
+            minimum_capacity_units=1,
+            maximum_on_demand_capacity_units=4,
+            maximum_core_capacity_units=2
+        )
+    )
+)
+```
+
 ### Termination Protection
 
 Locks a cluster (job flow) so the EC2 instances in the cluster cannot be
@@ -1263,13 +1383,13 @@ The following code snippet includes a Task state that uses eks:call to list the
 
 ```python
 import aws_cdk.aws_eks as eks
-from aws_cdk.lambda_layer_kubectl_v32 import KubectlV32Layer
+from aws_cdk.lambda_layer_kubectl_v34 import KubectlV34Layer
 
 
 my_eks_cluster = eks.Cluster(self, "my sample cluster",
-    version=eks.KubernetesVersion.V1_32,
+    version=eks.KubernetesVersion.V1_34,
     cluster_name="myEksCluster",
-    kubectl_layer=KubectlV32Layer(self, "kubectl")
+    kubectl_layer=KubectlV34Layer(self, "kubectl")
 )
 
 tasks.EksCall(self, "Call a EKS Endpoint",
@@ -1476,7 +1596,7 @@ connection = events.Connection(self, "Connection",
 
 tasks.HttpInvoke(self, "Invoke HTTP API",
     api_root="https://api.example.com",
-    api_endpoint=sfn.TaskInput.from_text("path/to/resource"),
+    api_endpoint=sfn.TaskInput.from_text(sfn.JsonPath.format("resource/{}/details", sfn.JsonPath.string_at("$.resourceId"))),
     body=sfn.TaskInput.from_object({"foo": "bar"}),
     connection=connection,
     headers=sfn.TaskInput.from_object({"Content-Type": "application/json"}),
@@ -2018,6 +2138,7 @@ from ..aws_ec2 import (
     Connections as _Connections_0f31fce8,
     IConnectable as _IConnectable_10015a05,
     ISecurityGroup as _ISecurityGroup_acf8a799,
+    ISubnet as _ISubnet_d57d1229,
     IVpc as _IVpc_f30d5663,
     InstanceSize as _InstanceSize_233b2620,
     InstanceType as _InstanceType_f64915b9,
@@ -2052,7 +2173,11 @@ from ..aws_iam import (
     PolicyStatement as _PolicyStatement_0fe33853,
 )
 from ..aws_kms import IKey as _IKey_5f11635f
-from ..aws_lambda import IFunction as _IFunction_6adb0ab8, Runtime as _Runtime_b4eaa844
+from ..aws_lambda import (
+    Architecture as _Architecture_12d5a53f,
+    IFunction as _IFunction_6adb0ab8,
+    Runtime as _Runtime_b4eaa844,
+)
 from ..aws_logs import ILogGroup as _ILogGroup_3c4fa718
 from ..aws_s3 import IBucket as _IBucket_42e086fd, Location as _Location_0948fa7f
 from ..aws_sns import ITopic as _ITopic_9eca4852
@@ -2073,6 +2198,8 @@ from ..aws_stepfunctions import (
     TaskStateJsonataBaseProps as _TaskStateJsonataBaseProps_0e91775c,
     Timeout as _Timeout_d7c10551,
 )
+from ..interfaces.aws_iam import IRoleRef as _IRoleRef_8400221f
+from ..interfaces.aws_kms import IKeyRef as _IKeyRef_d4fc6ef3
 
 
 class AcceleratorClass(
@@ -9826,6 +9953,791 @@ class BatchSubmitJobProps(_TaskStateBaseProps_3a62b6d0):
         )
 
 
+class BedrockCreateModelCustomizationJob(
+    _TaskStateBase_b5c0a816,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.BedrockCreateModelCustomizationJob",
+):
+    '''A Step Functions Task to create model customization in Bedrock.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        import aws_cdk.aws_bedrock as bedrock
+        import aws_cdk.aws_kms as kms
+        
+        # output_bucket: s3.IBucket
+        # training_bucket: s3.IBucket
+        # validation_bucket: s3.IBucket
+        # kms_key: kms.IKey
+        # vpc: ec2.IVpc
+        
+        
+        model = bedrock.FoundationModel.from_foundation_model_id(self, "Model", bedrock.FoundationModelIdentifier.AMAZON_TITAN_TEXT_G1_EXPRESS_V1)
+        
+        task = tasks.BedrockCreateModelCustomizationJob(self, "CreateModelCustomizationJob",
+            base_model=model,
+            client_request_token="MyToken",
+            customization_type=tasks.CustomizationType.FINE_TUNING,
+            custom_model_kms_key=kms_key,
+            custom_model_name="MyCustomModel",  # required
+            custom_model_tags=[tasks.CustomModelTag(key="key1", value="value1")],
+            hyper_parameters={
+                "batch_size": "10"
+            },
+            job_name="MyCustomizationJob",  # required
+            job_tags=[tasks.CustomModelTag(key="key2", value="value2")],
+            output_data=tasks.OutputBucketConfiguration(
+                bucket=output_bucket,  # required
+                path="output-data/"
+            ),
+            training_data=tasks.TrainingBucketConfiguration(
+                bucket=training_bucket,
+                path="training-data/data.json"
+            ),  # required
+            # If you don't provide validation data, you have to specify `Evaluation percentage` hyperparameter.
+            validation_data=[tasks.ValidationBucketConfiguration(
+                bucket=validation_bucket,
+                path="validation-data/data.json"
+            )
+            ],
+            vpc_config={
+                "security_groups": [ec2.SecurityGroup(self, "SecurityGroup", vpc=vpc)],
+                "subnets": vpc.private_subnets
+            }
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        base_model: _IModel_b88b328a,
+        custom_model_name: builtins.str,
+        job_name: builtins.str,
+        output_data: typing.Union["OutputBucketConfiguration", typing.Dict[builtins.str, typing.Any]],
+        training_data: typing.Union["TrainingBucketConfiguration", typing.Dict[builtins.str, typing.Any]],
+        client_request_token: typing.Optional[builtins.str] = None,
+        customization_type: typing.Optional["CustomizationType"] = None,
+        custom_model_kms_key: typing.Optional[_IKey_5f11635f] = None,
+        custom_model_tags: typing.Optional[typing.Sequence[typing.Union["CustomModelTag", typing.Dict[builtins.str, typing.Any]]]] = None,
+        hyper_parameters: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        job_tags: typing.Optional[typing.Sequence[typing.Union["CustomModelTag", typing.Dict[builtins.str, typing.Any]]]] = None,
+        role: typing.Optional[_IRoleRef_8400221f] = None,
+        validation_data: typing.Optional[typing.Sequence[typing.Union["ValidationBucketConfiguration", typing.Dict[builtins.str, typing.Any]]]] = None,
+        vpc_config: typing.Optional["IBedrockCreateModelCustomizationJobVpcConfig"] = None,
+        result_path: typing.Optional[builtins.str] = None,
+        result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+        comment: typing.Optional[builtins.str] = None,
+        query_language: typing.Optional[_QueryLanguage_be8414a8] = None,
+        state_name: 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,
+        integration_pattern: typing.Optional[_IntegrationPattern_949291bc] = None,
+        task_timeout: typing.Optional[_Timeout_d7c10551] = None,
+        timeout: typing.Optional[_Duration_4839e8c3] = None,
+        assign: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+        input_path: typing.Optional[builtins.str] = None,
+        output_path: typing.Optional[builtins.str] = None,
+        outputs: typing.Any = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param id: Descriptive identifier for this chainable.
+        :param base_model: The base model.
+        :param custom_model_name: A name for the resulting custom model. The maximum length is 63 characters.
+        :param job_name: A name for the fine-tuning job. The maximum length is 63 characters.
+        :param output_data: The S3 bucket configuration where the output data is stored.
+        :param training_data: The S3 bucket configuration where the training data is stored.
+        :param client_request_token: A unique, case-sensitive identifier to ensure that the API request completes no more than one time. If this token matches a previous request, Amazon Bedrock ignores the request, but does not return an error. The maximum length is 256 characters. Default: - no client request token
+        :param customization_type: The customization type. Default: FINE_TUNING
+        :param custom_model_kms_key: The custom model is encrypted at rest using this key. Default: - encrypted with the AWS owned key
+        :param custom_model_tags: Tags to attach to the resulting custom model. The maximum number of tags is 200. Default: - no tags
+        :param hyper_parameters: Parameters related to tuning the model. Default: - use default hyperparameters
+        :param job_tags: Tags to attach to the job. The maximum number of tags is 200. Default: - no tags
+        :param role: The IAM role that Amazon Bedrock can assume to perform tasks on your behalf. For example, during model training, Amazon Bedrock needs your permission to read input data from an S3 bucket, write model artifacts to an S3 bucket. To pass this role to Amazon Bedrock, the caller of this API must have the iam:PassRole permission. Default: - use auto generated role
+        :param validation_data: The S3 bucket configuration where the validation data is stored. If you don't provide a validation dataset, specify the evaluation percentage by the ``Evaluation percentage`` hyperparameter. The maximum number is 10. Default: undefined - validate using a subset of the training data
+        :param vpc_config: The VPC configuration. Default: - no VPC configuration
+        :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: $
+        :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 comment: A comment describing this state. Default: No comment
+        :param query_language: The name of the query language used by the state. If the state does not contain a ``queryLanguage`` field, then it will use the query language specified in the top-level ``queryLanguage`` field. Default: - JSONPath
+        :param state_name: Optional name for this state. Default: - The construct ID will be used as state name
+        :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 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 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 assign: Workflow variables to store in this step. Using workflow variables, you can store data in a step and retrieve that data in future steps. Default: - Not assign variables
+        :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: $
+        :param output_path: JSONPath expression to select part of the state to be the output to this state. May also be the special value JsonPath.DISCARD, which will cause the effective output to be the empty object {}. Default: $
+        :param outputs: Used to specify and transform output from the state. When specified, the value overrides the state output default. The output field accepts any JSON value (object, array, string, number, boolean, null). Any string value, including those inside objects or arrays, will be evaluated as JSONata if surrounded by {% %} characters. Output also accepts a JSONata expression directly. Default: - $states.result or $states.errorOutput
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__05f50c48ead9c1041aeef184ab271f7236e2832bc9e7175e9c6909f2fc4097e0)
+            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 = BedrockCreateModelCustomizationJobProps(
+            base_model=base_model,
+            custom_model_name=custom_model_name,
+            job_name=job_name,
+            output_data=output_data,
+            training_data=training_data,
+            client_request_token=client_request_token,
+            customization_type=customization_type,
+            custom_model_kms_key=custom_model_kms_key,
+            custom_model_tags=custom_model_tags,
+            hyper_parameters=hyper_parameters,
+            job_tags=job_tags,
+            role=role,
+            validation_data=validation_data,
+            vpc_config=vpc_config,
+            result_path=result_path,
+            result_selector=result_selector,
+            comment=comment,
+            query_language=query_language,
+            state_name=state_name,
+            credentials=credentials,
+            heartbeat=heartbeat,
+            heartbeat_timeout=heartbeat_timeout,
+            integration_pattern=integration_pattern,
+            task_timeout=task_timeout,
+            timeout=timeout,
+            assign=assign,
+            input_path=input_path,
+            output_path=output_path,
+            outputs=outputs,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @builtins.property
+    @jsii.member(jsii_name="role")
+    def role(self) -> _IRole_235f5d8e:
+        '''The IAM role for the bedrock create model customization job.'''
+        return typing.cast(_IRole_235f5d8e, jsii.get(self, "role"))
+
+    @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.BedrockCreateModelCustomizationJobProps",
+    jsii_struct_bases=[_TaskStateBaseProps_3a62b6d0],
+    name_mapping={
+        "comment": "comment",
+        "query_language": "queryLanguage",
+        "state_name": "stateName",
+        "credentials": "credentials",
+        "heartbeat": "heartbeat",
+        "heartbeat_timeout": "heartbeatTimeout",
+        "integration_pattern": "integrationPattern",
+        "task_timeout": "taskTimeout",
+        "timeout": "timeout",
+        "assign": "assign",
+        "input_path": "inputPath",
+        "output_path": "outputPath",
+        "outputs": "outputs",
+        "result_path": "resultPath",
+        "result_selector": "resultSelector",
+        "base_model": "baseModel",
+        "custom_model_name": "customModelName",
+        "job_name": "jobName",
+        "output_data": "outputData",
+        "training_data": "trainingData",
+        "client_request_token": "clientRequestToken",
+        "customization_type": "customizationType",
+        "custom_model_kms_key": "customModelKmsKey",
+        "custom_model_tags": "customModelTags",
+        "hyper_parameters": "hyperParameters",
+        "job_tags": "jobTags",
+        "role": "role",
+        "validation_data": "validationData",
+        "vpc_config": "vpcConfig",
+    },
+)
+class BedrockCreateModelCustomizationJobProps(_TaskStateBaseProps_3a62b6d0):
+    def __init__(
+        self,
+        *,
+        comment: typing.Optional[builtins.str] = None,
+        query_language: typing.Optional[_QueryLanguage_be8414a8] = None,
+        state_name: 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,
+        integration_pattern: typing.Optional[_IntegrationPattern_949291bc] = None,
+        task_timeout: typing.Optional[_Timeout_d7c10551] = None,
+        timeout: typing.Optional[_Duration_4839e8c3] = None,
+        assign: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+        input_path: typing.Optional[builtins.str] = None,
+        output_path: typing.Optional[builtins.str] = None,
+        outputs: typing.Any = None,
+        result_path: typing.Optional[builtins.str] = None,
+        result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+        base_model: _IModel_b88b328a,
+        custom_model_name: builtins.str,
+        job_name: builtins.str,
+        output_data: typing.Union["OutputBucketConfiguration", typing.Dict[builtins.str, typing.Any]],
+        training_data: typing.Union["TrainingBucketConfiguration", typing.Dict[builtins.str, typing.Any]],
+        client_request_token: typing.Optional[builtins.str] = None,
+        customization_type: typing.Optional["CustomizationType"] = None,
+        custom_model_kms_key: typing.Optional[_IKey_5f11635f] = None,
+        custom_model_tags: typing.Optional[typing.Sequence[typing.Union["CustomModelTag", typing.Dict[builtins.str, typing.Any]]]] = None,
+        hyper_parameters: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        job_tags: typing.Optional[typing.Sequence[typing.Union["CustomModelTag", typing.Dict[builtins.str, typing.Any]]]] = None,
+        role: typing.Optional[_IRoleRef_8400221f] = None,
+        validation_data: typing.Optional[typing.Sequence[typing.Union["ValidationBucketConfiguration", typing.Dict[builtins.str, typing.Any]]]] = None,
+        vpc_config: typing.Optional["IBedrockCreateModelCustomizationJobVpcConfig"] = None,
+    ) -> None:
+        '''Properties for invoking a Bedrock Model.
+
+        :param comment: A comment describing this state. Default: No comment
+        :param query_language: The name of the query language used by the state. If the state does not contain a ``queryLanguage`` field, then it will use the query language specified in the top-level ``queryLanguage`` field. Default: - JSONPath
+        :param state_name: Optional name for this state. Default: - The construct ID will be used as state name
+        :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 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 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 assign: Workflow variables to store in this step. Using workflow variables, you can store data in a step and retrieve that data in future steps. Default: - Not assign variables
+        :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: $
+        :param output_path: JSONPath expression to select part of the state to be the output to this state. May also be the special value JsonPath.DISCARD, which will cause the effective output to be the empty object {}. Default: $
+        :param outputs: Used to specify and transform output from the state. When specified, the value overrides the state output default. The output field accepts any JSON value (object, array, string, number, boolean, null). Any string value, including those inside objects or arrays, will be evaluated as JSONata if surrounded by {% %} characters. Output also accepts a JSONata expression directly. Default: - $states.result or $states.errorOutput
+        :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: $
+        :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 base_model: The base model.
+        :param custom_model_name: A name for the resulting custom model. The maximum length is 63 characters.
+        :param job_name: A name for the fine-tuning job. The maximum length is 63 characters.
+        :param output_data: The S3 bucket configuration where the output data is stored.
+        :param training_data: The S3 bucket configuration where the training data is stored.
+        :param client_request_token: A unique, case-sensitive identifier to ensure that the API request completes no more than one time. If this token matches a previous request, Amazon Bedrock ignores the request, but does not return an error. The maximum length is 256 characters. Default: - no client request token
+        :param customization_type: The customization type. Default: FINE_TUNING
+        :param custom_model_kms_key: The custom model is encrypted at rest using this key. Default: - encrypted with the AWS owned key
+        :param custom_model_tags: Tags to attach to the resulting custom model. The maximum number of tags is 200. Default: - no tags
+        :param hyper_parameters: Parameters related to tuning the model. Default: - use default hyperparameters
+        :param job_tags: Tags to attach to the job. The maximum number of tags is 200. Default: - no tags
+        :param role: The IAM role that Amazon Bedrock can assume to perform tasks on your behalf. For example, during model training, Amazon Bedrock needs your permission to read input data from an S3 bucket, write model artifacts to an S3 bucket. To pass this role to Amazon Bedrock, the caller of this API must have the iam:PassRole permission. Default: - use auto generated role
+        :param validation_data: The S3 bucket configuration where the validation data is stored. If you don't provide a validation dataset, specify the evaluation percentage by the ``Evaluation percentage`` hyperparameter. The maximum number is 10. Default: undefined - validate using a subset of the training data
+        :param vpc_config: The VPC configuration. Default: - no VPC configuration
+
+        :exampleMetadata: infused
+
+        Example::
+
+            import aws_cdk.aws_bedrock as bedrock
+            import aws_cdk.aws_kms as kms
+            
+            # output_bucket: s3.IBucket
+            # training_bucket: s3.IBucket
+            # validation_bucket: s3.IBucket
+            # kms_key: kms.IKey
+            # vpc: ec2.IVpc
+            
+            
+            model = bedrock.FoundationModel.from_foundation_model_id(self, "Model", bedrock.FoundationModelIdentifier.AMAZON_TITAN_TEXT_G1_EXPRESS_V1)
+            
+            task = tasks.BedrockCreateModelCustomizationJob(self, "CreateModelCustomizationJob",
+                base_model=model,
+                client_request_token="MyToken",
+                customization_type=tasks.CustomizationType.FINE_TUNING,
+                custom_model_kms_key=kms_key,
+                custom_model_name="MyCustomModel",  # required
+                custom_model_tags=[tasks.CustomModelTag(key="key1", value="value1")],
+                hyper_parameters={
+                    "batch_size": "10"
+                },
+                job_name="MyCustomizationJob",  # required
+                job_tags=[tasks.CustomModelTag(key="key2", value="value2")],
+                output_data=tasks.OutputBucketConfiguration(
+                    bucket=output_bucket,  # required
+                    path="output-data/"
+                ),
+                training_data=tasks.TrainingBucketConfiguration(
+                    bucket=training_bucket,
+                    path="training-data/data.json"
+                ),  # required
+                # If you don't provide validation data, you have to specify `Evaluation percentage` hyperparameter.
+                validation_data=[tasks.ValidationBucketConfiguration(
+                    bucket=validation_bucket,
+                    path="validation-data/data.json"
+                )
+                ],
+                vpc_config={
+                    "security_groups": [ec2.SecurityGroup(self, "SecurityGroup", vpc=vpc)],
+                    "subnets": vpc.private_subnets
+                }
+            )
+        '''
+        if isinstance(credentials, dict):
+            credentials = _Credentials_2cd64c6b(**credentials)
+        if isinstance(output_data, dict):
+            output_data = OutputBucketConfiguration(**output_data)
+        if isinstance(training_data, dict):
+            training_data = TrainingBucketConfiguration(**training_data)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__4a1348489dd866713bad4f53a20bf5de0eff5edebddfb3011e85cf03da5f68d2)
+            check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
+            check_type(argname="argument query_language", value=query_language, expected_type=type_hints["query_language"])
+            check_type(argname="argument state_name", value=state_name, expected_type=type_hints["state_name"])
+            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 integration_pattern", value=integration_pattern, expected_type=type_hints["integration_pattern"])
+            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 assign", value=assign, expected_type=type_hints["assign"])
+            check_type(argname="argument input_path", value=input_path, expected_type=type_hints["input_path"])
+            check_type(argname="argument output_path", value=output_path, expected_type=type_hints["output_path"])
+            check_type(argname="argument outputs", value=outputs, expected_type=type_hints["outputs"])
+            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 base_model", value=base_model, expected_type=type_hints["base_model"])
+            check_type(argname="argument custom_model_name", value=custom_model_name, expected_type=type_hints["custom_model_name"])
+            check_type(argname="argument job_name", value=job_name, expected_type=type_hints["job_name"])
+            check_type(argname="argument output_data", value=output_data, expected_type=type_hints["output_data"])
+            check_type(argname="argument training_data", value=training_data, expected_type=type_hints["training_data"])
+            check_type(argname="argument client_request_token", value=client_request_token, expected_type=type_hints["client_request_token"])
+            check_type(argname="argument customization_type", value=customization_type, expected_type=type_hints["customization_type"])
+            check_type(argname="argument custom_model_kms_key", value=custom_model_kms_key, expected_type=type_hints["custom_model_kms_key"])
+            check_type(argname="argument custom_model_tags", value=custom_model_tags, expected_type=type_hints["custom_model_tags"])
+            check_type(argname="argument hyper_parameters", value=hyper_parameters, expected_type=type_hints["hyper_parameters"])
+            check_type(argname="argument job_tags", value=job_tags, expected_type=type_hints["job_tags"])
+            check_type(argname="argument role", value=role, expected_type=type_hints["role"])
+            check_type(argname="argument validation_data", value=validation_data, expected_type=type_hints["validation_data"])
+            check_type(argname="argument vpc_config", value=vpc_config, expected_type=type_hints["vpc_config"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "base_model": base_model,
+            "custom_model_name": custom_model_name,
+            "job_name": job_name,
+            "output_data": output_data,
+            "training_data": training_data,
+        }
+        if comment is not None:
+            self._values["comment"] = comment
+        if query_language is not None:
+            self._values["query_language"] = query_language
+        if state_name is not None:
+            self._values["state_name"] = state_name
+        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 integration_pattern is not None:
+            self._values["integration_pattern"] = integration_pattern
+        if task_timeout is not None:
+            self._values["task_timeout"] = task_timeout
+        if timeout is not None:
+            self._values["timeout"] = timeout
+        if assign is not None:
+            self._values["assign"] = assign
+        if input_path is not None:
+            self._values["input_path"] = input_path
+        if output_path is not None:
+            self._values["output_path"] = output_path
+        if outputs is not None:
+            self._values["outputs"] = outputs
+        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 client_request_token is not None:
+            self._values["client_request_token"] = client_request_token
+        if customization_type is not None:
+            self._values["customization_type"] = customization_type
+        if custom_model_kms_key is not None:
+            self._values["custom_model_kms_key"] = custom_model_kms_key
+        if custom_model_tags is not None:
+            self._values["custom_model_tags"] = custom_model_tags
+        if hyper_parameters is not None:
+            self._values["hyper_parameters"] = hyper_parameters
+        if job_tags is not None:
+            self._values["job_tags"] = job_tags
+        if role is not None:
+            self._values["role"] = role
+        if validation_data is not None:
+            self._values["validation_data"] = validation_data
+        if vpc_config is not None:
+            self._values["vpc_config"] = vpc_config
+
+    @builtins.property
+    def comment(self) -> typing.Optional[builtins.str]:
+        '''A comment describing this state.
+
+        :default: No comment
+        '''
+        result = self._values.get("comment")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def query_language(self) -> typing.Optional[_QueryLanguage_be8414a8]:
+        '''The name of the query language used by the state.
+
+        If the state does not contain a ``queryLanguage`` field,
+        then it will use the query language specified in the top-level ``queryLanguage`` field.
+
+        :default: - JSONPath
+        '''
+        result = self._values.get("query_language")
+        return typing.cast(typing.Optional[_QueryLanguage_be8414a8], 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 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 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 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 assign(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
+        '''Workflow variables to store in this step.
+
+        Using workflow variables, you can store data in a step and retrieve that data in future steps.
+
+        :default: - Not assign variables
+
+        :see: https://docs.aws.amazon.com/step-functions/latest/dg/workflow-variables.html
+        '''
+        result = self._values.get("assign")
+        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], 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: $
+        '''
+        result = self._values.get("input_path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def output_path(self) -> typing.Optional[builtins.str]:
+        '''JSONPath expression to select part of the state to be the output to this state.
+
+        May also be the special value JsonPath.DISCARD, which will cause the effective
+        output to be the empty object {}.
+
+        :default: $
+        '''
+        result = self._values.get("output_path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def outputs(self) -> typing.Any:
+        '''Used to specify and transform output from the state.
+
+        When specified, the value overrides the state output default.
+        The output field accepts any JSON value (object, array, string, number, boolean, null).
+        Any string value, including those inside objects or arrays,
+        will be evaluated as JSONata if surrounded by {% %} characters.
+        Output also accepts a JSONata expression directly.
+
+        :default: - $states.result or $states.errorOutput
+
+        :see: https://docs.aws.amazon.com/step-functions/latest/dg/concepts-input-output-filtering.html
+        '''
+        result = self._values.get("outputs")
+        return typing.cast(typing.Any, 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: $
+        '''
+        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 base_model(self) -> _IModel_b88b328a:
+        '''The base model.'''
+        result = self._values.get("base_model")
+        assert result is not None, "Required property 'base_model' is missing"
+        return typing.cast(_IModel_b88b328a, result)
+
+    @builtins.property
+    def custom_model_name(self) -> builtins.str:
+        '''A name for the resulting custom model.
+
+        The maximum length is 63 characters.
+        '''
+        result = self._values.get("custom_model_name")
+        assert result is not None, "Required property 'custom_model_name' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def job_name(self) -> builtins.str:
+        '''A name for the fine-tuning job.
+
+        The maximum length is 63 characters.
+        '''
+        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 output_data(self) -> "OutputBucketConfiguration":
+        '''The S3 bucket configuration where the output data is stored.
+
+        :see: https://docs.aws.amazon.com/bedrock/latest/APIReference/API_OutputDataConfig.html
+        '''
+        result = self._values.get("output_data")
+        assert result is not None, "Required property 'output_data' is missing"
+        return typing.cast("OutputBucketConfiguration", result)
+
+    @builtins.property
+    def training_data(self) -> "TrainingBucketConfiguration":
+        '''The S3 bucket configuration where the training data is stored.
+
+        :see: https://docs.aws.amazon.com/bedrock/latest/APIReference/API_TrainingDataConfig.html
+        '''
+        result = self._values.get("training_data")
+        assert result is not None, "Required property 'training_data' is missing"
+        return typing.cast("TrainingBucketConfiguration", result)
+
+    @builtins.property
+    def client_request_token(self) -> typing.Optional[builtins.str]:
+        '''A unique, case-sensitive identifier to ensure that the API request completes no more than one time.
+
+        If this token matches a previous request, Amazon Bedrock ignores the request, but does not return an error.
+
+        The maximum length is 256 characters.
+
+        :default: - no client request token
+
+        :see: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html
+        '''
+        result = self._values.get("client_request_token")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def customization_type(self) -> typing.Optional["CustomizationType"]:
+        '''The customization type.
+
+        :default: FINE_TUNING
+        '''
+        result = self._values.get("customization_type")
+        return typing.cast(typing.Optional["CustomizationType"], result)
+
+    @builtins.property
+    def custom_model_kms_key(self) -> typing.Optional[_IKey_5f11635f]:
+        '''The custom model is encrypted at rest using this key.
+
+        :default: - encrypted with the AWS owned key
+
+        :see: https://docs.aws.amazon.com/bedrock/latest/userguide/encryption-custom-job.html
+        '''
+        result = self._values.get("custom_model_kms_key")
+        return typing.cast(typing.Optional[_IKey_5f11635f], result)
+
+    @builtins.property
+    def custom_model_tags(self) -> typing.Optional[typing.List["CustomModelTag"]]:
+        '''Tags to attach to the resulting custom model.
+
+        The maximum number of tags is 200.
+
+        :default: - no tags
+        '''
+        result = self._values.get("custom_model_tags")
+        return typing.cast(typing.Optional[typing.List["CustomModelTag"]], result)
+
+    @builtins.property
+    def hyper_parameters(
+        self,
+    ) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
+        '''Parameters related to tuning the model.
+
+        :default: - use default hyperparameters
+
+        :see: https://docs.aws.amazon.com/bedrock/latest/userguide/custom-models-hp.html
+        '''
+        result = self._values.get("hyper_parameters")
+        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
+
+    @builtins.property
+    def job_tags(self) -> typing.Optional[typing.List["CustomModelTag"]]:
+        '''Tags to attach to the job.
+
+        The maximum number of tags is 200.
+
+        :default: - no tags
+        '''
+        result = self._values.get("job_tags")
+        return typing.cast(typing.Optional[typing.List["CustomModelTag"]], result)
+
+    @builtins.property
+    def role(self) -> typing.Optional[_IRoleRef_8400221f]:
+        '''The IAM role that Amazon Bedrock can assume to perform tasks on your behalf.
+
+        For example, during model training, Amazon Bedrock needs your permission to read input data from an S3 bucket,
+        write model artifacts to an S3 bucket.
+        To pass this role to Amazon Bedrock, the caller of this API must have the iam:PassRole permission.
+
+        :default: - use auto generated role
+        '''
+        result = self._values.get("role")
+        return typing.cast(typing.Optional[_IRoleRef_8400221f], result)
+
+    @builtins.property
+    def validation_data(
+        self,
+    ) -> typing.Optional[typing.List["ValidationBucketConfiguration"]]:
+        '''The S3 bucket configuration where the validation data is stored.
+
+        If you don't provide a validation dataset, specify the evaluation percentage by the ``Evaluation percentage`` hyperparameter.
+
+        The maximum number is 10.
+
+        :default: undefined - validate using a subset of the training data
+
+        :see: https://docs.aws.amazon.com/bedrock/latest/APIReference/API_Validator.html
+        '''
+        result = self._values.get("validation_data")
+        return typing.cast(typing.Optional[typing.List["ValidationBucketConfiguration"]], result)
+
+    @builtins.property
+    def vpc_config(
+        self,
+    ) -> typing.Optional["IBedrockCreateModelCustomizationJobVpcConfig"]:
+        '''The VPC configuration.
+
+        :default: - no VPC configuration
+        '''
+        result = self._values.get("vpc_config")
+        return typing.cast(typing.Optional["IBedrockCreateModelCustomizationJobVpcConfig"], 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 "BedrockCreateModelCustomizationJobProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 class BedrockInvokeModel(
     _TaskStateBase_b5c0a816,
     metaclass=jsii.JSIIMeta,
@@ -13434,6 +14346,12 @@ class CallApiGatewayHttpApiEndpoint(
     def _create_policy_statements(self) -> typing.List[_PolicyStatement_0fe33853]:
         return typing.cast(typing.List[_PolicyStatement_0fe33853], jsii.invoke(self, "createPolicyStatements", []))
 
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="PROPERTY_INJECTION_ID")
+    def PROPERTY_INJECTION_ID(cls) -> builtins.str:
+        '''Uniquely identifies this class.'''
+        return typing.cast(builtins.str, jsii.sget(cls, "PROPERTY_INJECTION_ID"))
+
     @builtins.property
     @jsii.member(jsii_name="apiEndpoint")
     def _api_endpoint(self) -> builtins.str:
@@ -14364,6 +15282,12 @@ class CallApiGatewayRestApiEndpoint(
     def _create_policy_statements(self) -> typing.List[_PolicyStatement_0fe33853]:
         return typing.cast(typing.List[_PolicyStatement_0fe33853], jsii.invoke(self, "createPolicyStatements", []))
 
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="PROPERTY_INJECTION_ID")
+    def PROPERTY_INJECTION_ID(cls) -> builtins.str:
+        '''Uniquely identifies this class.'''
+        return typing.cast(builtins.str, jsii.sget(cls, "PROPERTY_INJECTION_ID"))
+
     @builtins.property
     @jsii.member(jsii_name="apiEndpoint")
     def _api_endpoint(self) -> builtins.str:
@@ -21950,6 +22874,211 @@ class CronOptions:
         )
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.CustomModelTag",
+    jsii_struct_bases=[],
+    name_mapping={"key": "key", "value": "value"},
+)
+class CustomModelTag:
+    def __init__(self, *, key: builtins.str, value: builtins.str) -> None:
+        '''The key/value pair for a tag.
+
+        :param key: Key for the tag.
+        :param value: Value for the tag.
+
+        :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
+            
+            custom_model_tag = stepfunctions_tasks.CustomModelTag(
+                key="key",
+                value="value"
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__83c62fca1c3250b9c5ee6e19dd3dfc1c4accd6cbf494208ce8b177e8b37ab802)
+            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "key": key,
+            "value": value,
+        }
+
+    @builtins.property
+    def key(self) -> builtins.str:
+        '''Key for the tag.'''
+        result = self._values.get("key")
+        assert result is not None, "Required property 'key' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def value(self) -> builtins.str:
+        '''Value for the tag.'''
+        result = self._values.get("value")
+        assert result is not None, "Required property 'value' 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 "CustomModelTag(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.enum(jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.CustomizationType")
+class CustomizationType(enum.Enum):
+    '''The customization type.
+
+    :see: https://docs.aws.amazon.com/bedrock/latest/userguide/custom-models.html
+    :exampleMetadata: infused
+
+    Example::
+
+        import aws_cdk.aws_bedrock as bedrock
+        import aws_cdk.aws_kms as kms
+        
+        # output_bucket: s3.IBucket
+        # training_bucket: s3.IBucket
+        # validation_bucket: s3.IBucket
+        # kms_key: kms.IKey
+        # vpc: ec2.IVpc
+        
+        
+        model = bedrock.FoundationModel.from_foundation_model_id(self, "Model", bedrock.FoundationModelIdentifier.AMAZON_TITAN_TEXT_G1_EXPRESS_V1)
+        
+        task = tasks.BedrockCreateModelCustomizationJob(self, "CreateModelCustomizationJob",
+            base_model=model,
+            client_request_token="MyToken",
+            customization_type=tasks.CustomizationType.FINE_TUNING,
+            custom_model_kms_key=kms_key,
+            custom_model_name="MyCustomModel",  # required
+            custom_model_tags=[tasks.CustomModelTag(key="key1", value="value1")],
+            hyper_parameters={
+                "batch_size": "10"
+            },
+            job_name="MyCustomizationJob",  # required
+            job_tags=[tasks.CustomModelTag(key="key2", value="value2")],
+            output_data=tasks.OutputBucketConfiguration(
+                bucket=output_bucket,  # required
+                path="output-data/"
+            ),
+            training_data=tasks.TrainingBucketConfiguration(
+                bucket=training_bucket,
+                path="training-data/data.json"
+            ),  # required
+            # If you don't provide validation data, you have to specify `Evaluation percentage` hyperparameter.
+            validation_data=[tasks.ValidationBucketConfiguration(
+                bucket=validation_bucket,
+                path="validation-data/data.json"
+            )
+            ],
+            vpc_config={
+                "security_groups": [ec2.SecurityGroup(self, "SecurityGroup", vpc=vpc)],
+                "subnets": vpc.private_subnets
+            }
+        )
+    '''
+
+    FINE_TUNING = "FINE_TUNING"
+    '''Fine-tuning.
+
+    Provide labeled data in order to train a model to improve performance on specific tasks.
+    '''
+    CONTINUED_PRE_TRAINING = "CONTINUED_PRE_TRAINING"
+    '''Continued pre-training.
+
+    Provide unlabeled data to pre-train a foundation model by familiarizing it with certain types of inputs.
+    '''
+    DISTILLATION = "DISTILLATION"
+    '''Distillation.
+
+    With Model Distillation, you can generate synthetic responses from a large foundation model (teacher)
+    and use that data to train a smaller model (student) for your specific use-case.
+    '''
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.DataBucketConfiguration",
+    jsii_struct_bases=[],
+    name_mapping={"bucket": "bucket", "path": "path"},
+)
+class DataBucketConfiguration:
+    def __init__(
+        self,
+        *,
+        bucket: _IBucket_42e086fd,
+        path: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''S3 bucket configuration for data storage destination.
+
+        :param bucket: The S3 bucket.
+        :param path: Path to file or directory within the bucket. Default: - root of the bucket
+
+        :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_s3 as s3
+            from aws_cdk import aws_stepfunctions_tasks as stepfunctions_tasks
+            
+            # bucket: s3.Bucket
+            
+            data_bucket_configuration = stepfunctions_tasks.DataBucketConfiguration(
+                bucket=bucket,
+            
+                # the properties below are optional
+                path="path"
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__a310fa6911b62dab87f8ad67600f727aa7262c59f0ca09c7df5e3e7af25a63ee)
+            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
+            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "bucket": bucket,
+        }
+        if path is not None:
+            self._values["path"] = path
+
+    @builtins.property
+    def bucket(self) -> _IBucket_42e086fd:
+        '''The S3 bucket.'''
+        result = self._values.get("bucket")
+        assert result is not None, "Required property 'bucket' is missing"
+        return typing.cast(_IBucket_42e086fd, result)
+
+    @builtins.property
+    def path(self) -> typing.Optional[builtins.str]:
+        '''Path to file or directory within the bucket.
+
+        :default: - root of the bucket
+        '''
+        result = self._values.get("path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "DataBucketConfiguration(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.DataSource",
     jsii_struct_bases=[],
@@ -29885,6 +31014,12 @@ class EcsRunTask(
 
         return typing.cast("EcsRunTask", jsii.sinvoke(cls, "jsonPath", [scope, id, props]))
 
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="PROPERTY_INJECTION_ID")
+    def PROPERTY_INJECTION_ID(cls) -> builtins.str:
+        '''Uniquely identifies this class.'''
+        return typing.cast(builtins.str, jsii.sget(cls, "PROPERTY_INJECTION_ID"))
+
     @builtins.property
     @jsii.member(jsii_name="connections")
     def connections(self) -> _Connections_0f31fce8:
@@ -31538,13 +32673,13 @@ class EksCall(
     Example::
 
         import aws_cdk.aws_eks as eks
-        from aws_cdk.lambda_layer_kubectl_v32 import KubectlV32Layer
+        from aws_cdk.lambda_layer_kubectl_v34 import KubectlV34Layer
         
         
         my_eks_cluster = eks.Cluster(self, "my sample cluster",
-            version=eks.KubernetesVersion.V1_32,
+            version=eks.KubernetesVersion.V1_34,
             cluster_name="myEksCluster",
-            kubectl_layer=KubectlV32Layer(self, "kubectl")
+            kubectl_layer=KubectlV34Layer(self, "kubectl")
         )
         
         tasks.EksCall(self, "Call a EKS Endpoint",
@@ -32646,13 +33781,13 @@ class EksCallProps(_TaskStateBaseProps_3a62b6d0):
         Example::
 
             import aws_cdk.aws_eks as eks
-            from aws_cdk.lambda_layer_kubectl_v32 import KubectlV32Layer
+            from aws_cdk.lambda_layer_kubectl_v34 import KubectlV34Layer
             
             
             my_eks_cluster = eks.Cluster(self, "my sample cluster",
-                version=eks.KubernetesVersion.V1_32,
+                version=eks.KubernetesVersion.V1_34,
                 cluster_name="myEksCluster",
-                kubectl_layer=KubectlV32Layer(self, "kubectl")
+                kubectl_layer=KubectlV34Layer(self, "kubectl")
             )
             
             tasks.EksCall(self, "Call a EKS Endpoint",
@@ -40247,34 +41382,36 @@ class EmrCreateCluster(
 
     Example::
 
-        cluster_role = iam.Role(self, "ClusterRole",
-            assumed_by=iam.ServicePrincipal("ec2.amazonaws.com")
-        )
-        
-        service_role = iam.Role(self, "ServiceRole",
-            assumed_by=iam.ServicePrincipal("elasticmapreduce.amazonaws.com")
-        )
-        
-        auto_scaling_role = iam.Role(self, "AutoScalingRole",
-            assumed_by=iam.ServicePrincipal("elasticmapreduce.amazonaws.com")
-        )
-        
-        auto_scaling_role.assume_role_policy.add_statements(
-            iam.PolicyStatement(
-                effect=iam.Effect.ALLOW,
-                principals=[
-                    iam.ServicePrincipal("application-autoscaling.amazonaws.com")
-                ],
-                actions=["sts:AssumeRole"
+        tasks.EmrCreateCluster(self, "CreateCluster",
+            instances=tasks.EmrCreateCluster.InstancesConfigProperty(
+                instance_fleets=[tasks.EmrCreateCluster.InstanceFleetConfigProperty(
+                    instance_fleet_type=tasks.EmrCreateCluster.InstanceRoleType.CORE,
+                    instance_type_configs=[tasks.EmrCreateCluster.InstanceTypeConfigProperty(
+                        instance_type="m5.xlarge"
+                    )
+                    ],
+                    target_on_demand_capacity=1
+                ), tasks.EmrCreateCluster.InstanceFleetConfigProperty(
+                    instance_fleet_type=tasks.EmrCreateCluster.InstanceRoleType.MASTER,
+                    instance_type_configs=[tasks.EmrCreateCluster.InstanceTypeConfigProperty(
+                        instance_type="m5.xlarge"
+                    )
+                    ],
+                    target_on_demand_capacity=1
+                )
                 ]
-            ))
-        
-        tasks.EmrCreateCluster(self, "Create Cluster",
-            instances=tasks.EmrCreateCluster.InstancesConfigProperty(),
-            cluster_role=cluster_role,
-            name=sfn.TaskInput.from_json_path_at("$.ClusterName").value,
-            service_role=service_role,
-            auto_scaling_role=auto_scaling_role
+            ),
+            name="ClusterName",
+            release_label="emr-7.9.0",
+            managed_scaling_policy=tasks.EmrCreateCluster.ManagedScalingPolicyProperty(
+                compute_limits=tasks.EmrCreateCluster.ManagedScalingComputeLimitsProperty(
+                    unit_type=tasks.EmrCreateCluster.ComputeLimitsUnitType.INSTANCE_FLEET_UNITS,
+                    maximum_capacity_units=4,
+                    minimum_capacity_units=1,
+                    maximum_on_demand_capacity_units=4,
+                    maximum_core_capacity_units=2
+                )
+            )
         )
     '''
 
@@ -40293,9 +41430,12 @@ class EmrCreateCluster(
         cluster_role: typing.Optional[_IRole_235f5d8e] = None,
         configurations: typing.Optional[typing.Sequence[typing.Union["EmrCreateCluster.ConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         custom_ami_id: typing.Optional[builtins.str] = None,
+        ebs_root_volume_iops: typing.Optional[jsii.Number] = None,
         ebs_root_volume_size: typing.Optional[_Size_7b441c34] = None,
+        ebs_root_volume_throughput: typing.Optional[jsii.Number] = None,
         kerberos_attributes: typing.Optional[typing.Union["EmrCreateCluster.KerberosAttributesProperty", typing.Dict[builtins.str, typing.Any]]] = None,
         log_uri: typing.Optional[builtins.str] = None,
+        managed_scaling_policy: typing.Optional[typing.Union["EmrCreateCluster.ManagedScalingPolicyProperty", typing.Dict[builtins.str, typing.Any]]] = None,
         release_label: typing.Optional[builtins.str] = None,
         scale_down_behavior: typing.Optional["EmrCreateCluster.EmrClusterScaleDownBehavior"] = None,
         security_configuration: typing.Optional[builtins.str] = None,
@@ -40332,9 +41472,12 @@ class EmrCreateCluster(
         :param cluster_role: Also called instance profile and EC2 role. An IAM role for an EMR cluster. The EC2 instances of the cluster assume this role. This attribute has been renamed from jobFlowRole to clusterRole to align with other ERM/StepFunction integration parameters. Default: - - A Role will be created
         :param configurations: The list of configurations supplied for the EMR cluster you are creating. Default: - None
         :param custom_ami_id: The ID of a custom Amazon EBS-backed Linux AMI. Default: - None
+        :param ebs_root_volume_iops: The IOPS of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Requires EMR release label 6.15.0 or above. Must be in range [3000, 16000]. Default: - EMR selected default
         :param ebs_root_volume_size: The size of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Default: - EMR selected default
+        :param ebs_root_volume_throughput: The throughput, in MiB/s, of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Requires EMR release label 6.15.0 or above. Must be in range [125, 1000]. Default: - EMR selected default
         :param kerberos_attributes: Attributes for Kerberos configuration when Kerberos authentication is enabled using a security configuration. Default: - None
         :param log_uri: The location in Amazon S3 to write the log files of the job flow. Default: - None
+        :param managed_scaling_policy: The specified managed scaling policy for an Amazon EMR cluster. Default: - None
         :param release_label: The Amazon EMR release label, which determines the version of open-source application packages installed on the cluster. Default: - EMR selected default
         :param scale_down_behavior: Specifies the way that individual Amazon EC2 instances terminate when an automatic scale-in activity occurs or an instance group is resized. Default: - EMR selected default
         :param security_configuration: The name of a security configuration to apply to the cluster. Default: - None
@@ -40373,9 +41516,12 @@ class EmrCreateCluster(
             cluster_role=cluster_role,
             configurations=configurations,
             custom_ami_id=custom_ami_id,
+            ebs_root_volume_iops=ebs_root_volume_iops,
             ebs_root_volume_size=ebs_root_volume_size,
+            ebs_root_volume_throughput=ebs_root_volume_throughput,
             kerberos_attributes=kerberos_attributes,
             log_uri=log_uri,
+            managed_scaling_policy=managed_scaling_policy,
             release_label=release_label,
             scale_down_behavior=scale_down_behavior,
             security_configuration=security_configuration,
@@ -40419,9 +41565,12 @@ class EmrCreateCluster(
         cluster_role: typing.Optional[_IRole_235f5d8e] = None,
         configurations: typing.Optional[typing.Sequence[typing.Union["EmrCreateCluster.ConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         custom_ami_id: typing.Optional[builtins.str] = None,
+        ebs_root_volume_iops: typing.Optional[jsii.Number] = None,
         ebs_root_volume_size: typing.Optional[_Size_7b441c34] = None,
+        ebs_root_volume_throughput: typing.Optional[jsii.Number] = None,
         kerberos_attributes: typing.Optional[typing.Union["EmrCreateCluster.KerberosAttributesProperty", typing.Dict[builtins.str, typing.Any]]] = None,
         log_uri: typing.Optional[builtins.str] = None,
+        managed_scaling_policy: typing.Optional[typing.Union["EmrCreateCluster.ManagedScalingPolicyProperty", typing.Dict[builtins.str, typing.Any]]] = None,
         release_label: typing.Optional[builtins.str] = None,
         scale_down_behavior: typing.Optional["EmrCreateCluster.EmrClusterScaleDownBehavior"] = None,
         security_configuration: typing.Optional[builtins.str] = None,
@@ -40457,9 +41606,12 @@ class EmrCreateCluster(
         :param cluster_role: Also called instance profile and EC2 role. An IAM role for an EMR cluster. The EC2 instances of the cluster assume this role. This attribute has been renamed from jobFlowRole to clusterRole to align with other ERM/StepFunction integration parameters. Default: - - A Role will be created
         :param configurations: The list of configurations supplied for the EMR cluster you are creating. Default: - None
         :param custom_ami_id: The ID of a custom Amazon EBS-backed Linux AMI. Default: - None
+        :param ebs_root_volume_iops: The IOPS of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Requires EMR release label 6.15.0 or above. Must be in range [3000, 16000]. Default: - EMR selected default
         :param ebs_root_volume_size: The size of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Default: - EMR selected default
+        :param ebs_root_volume_throughput: The throughput, in MiB/s, of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Requires EMR release label 6.15.0 or above. Must be in range [125, 1000]. Default: - EMR selected default
         :param kerberos_attributes: Attributes for Kerberos configuration when Kerberos authentication is enabled using a security configuration. Default: - None
         :param log_uri: The location in Amazon S3 to write the log files of the job flow. Default: - None
+        :param managed_scaling_policy: The specified managed scaling policy for an Amazon EMR cluster. Default: - None
         :param release_label: The Amazon EMR release label, which determines the version of open-source application packages installed on the cluster. Default: - EMR selected default
         :param scale_down_behavior: Specifies the way that individual Amazon EC2 instances terminate when an automatic scale-in activity occurs or an instance group is resized. Default: - EMR selected default
         :param security_configuration: The name of a security configuration to apply to the cluster. Default: - None
@@ -40494,9 +41646,12 @@ class EmrCreateCluster(
             cluster_role=cluster_role,
             configurations=configurations,
             custom_ami_id=custom_ami_id,
+            ebs_root_volume_iops=ebs_root_volume_iops,
             ebs_root_volume_size=ebs_root_volume_size,
+            ebs_root_volume_throughput=ebs_root_volume_throughput,
             kerberos_attributes=kerberos_attributes,
             log_uri=log_uri,
+            managed_scaling_policy=managed_scaling_policy,
             release_label=release_label,
             scale_down_behavior=scale_down_behavior,
             security_configuration=security_configuration,
@@ -40536,9 +41691,12 @@ class EmrCreateCluster(
         cluster_role: typing.Optional[_IRole_235f5d8e] = None,
         configurations: typing.Optional[typing.Sequence[typing.Union["EmrCreateCluster.ConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         custom_ami_id: typing.Optional[builtins.str] = None,
+        ebs_root_volume_iops: typing.Optional[jsii.Number] = None,
         ebs_root_volume_size: typing.Optional[_Size_7b441c34] = None,
+        ebs_root_volume_throughput: typing.Optional[jsii.Number] = None,
         kerberos_attributes: typing.Optional[typing.Union["EmrCreateCluster.KerberosAttributesProperty", typing.Dict[builtins.str, typing.Any]]] = None,
         log_uri: typing.Optional[builtins.str] = None,
+        managed_scaling_policy: typing.Optional[typing.Union["EmrCreateCluster.ManagedScalingPolicyProperty", typing.Dict[builtins.str, typing.Any]]] = None,
         release_label: typing.Optional[builtins.str] = None,
         scale_down_behavior: typing.Optional["EmrCreateCluster.EmrClusterScaleDownBehavior"] = None,
         security_configuration: typing.Optional[builtins.str] = None,
@@ -40577,9 +41735,12 @@ class EmrCreateCluster(
         :param cluster_role: Also called instance profile and EC2 role. An IAM role for an EMR cluster. The EC2 instances of the cluster assume this role. This attribute has been renamed from jobFlowRole to clusterRole to align with other ERM/StepFunction integration parameters. Default: - - A Role will be created
         :param configurations: The list of configurations supplied for the EMR cluster you are creating. Default: - None
         :param custom_ami_id: The ID of a custom Amazon EBS-backed Linux AMI. Default: - None
+        :param ebs_root_volume_iops: The IOPS of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Requires EMR release label 6.15.0 or above. Must be in range [3000, 16000]. Default: - EMR selected default
         :param ebs_root_volume_size: The size of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Default: - EMR selected default
+        :param ebs_root_volume_throughput: The throughput, in MiB/s, of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Requires EMR release label 6.15.0 or above. Must be in range [125, 1000]. Default: - EMR selected default
         :param kerberos_attributes: Attributes for Kerberos configuration when Kerberos authentication is enabled using a security configuration. Default: - None
         :param log_uri: The location in Amazon S3 to write the log files of the job flow. Default: - None
+        :param managed_scaling_policy: The specified managed scaling policy for an Amazon EMR cluster. Default: - None
         :param release_label: The Amazon EMR release label, which determines the version of open-source application packages installed on the cluster. Default: - EMR selected default
         :param scale_down_behavior: Specifies the way that individual Amazon EC2 instances terminate when an automatic scale-in activity occurs or an instance group is resized. Default: - EMR selected default
         :param security_configuration: The name of a security configuration to apply to the cluster. Default: - None
@@ -40617,9 +41778,12 @@ class EmrCreateCluster(
             cluster_role=cluster_role,
             configurations=configurations,
             custom_ami_id=custom_ami_id,
+            ebs_root_volume_iops=ebs_root_volume_iops,
             ebs_root_volume_size=ebs_root_volume_size,
+            ebs_root_volume_throughput=ebs_root_volume_throughput,
             kerberos_attributes=kerberos_attributes,
             log_uri=log_uri,
+            managed_scaling_policy=managed_scaling_policy,
             release_label=release_label,
             scale_down_behavior=scale_down_behavior,
             security_configuration=security_configuration,
@@ -41280,6 +42444,57 @@ class EmrCreateCluster(
         COUNT_PER_SECOND = "COUNT_PER_SECOND"
         '''COUNT_PER_SECOND.'''
 
+    @jsii.enum(
+        jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.EmrCreateCluster.ComputeLimitsUnitType"
+    )
+    class ComputeLimitsUnitType(enum.Enum):
+        '''The unit type for managed scaling policy compute limits.
+
+        :see: https://docs.aws.amazon.com/emr/latest/APIReference/API_ComputeLimits.html
+        :exampleMetadata: infused
+
+        Example::
+
+            tasks.EmrCreateCluster(self, "CreateCluster",
+                instances=tasks.EmrCreateCluster.InstancesConfigProperty(
+                    instance_fleets=[tasks.EmrCreateCluster.InstanceFleetConfigProperty(
+                        instance_fleet_type=tasks.EmrCreateCluster.InstanceRoleType.CORE,
+                        instance_type_configs=[tasks.EmrCreateCluster.InstanceTypeConfigProperty(
+                            instance_type="m5.xlarge"
+                        )
+                        ],
+                        target_on_demand_capacity=1
+                    ), tasks.EmrCreateCluster.InstanceFleetConfigProperty(
+                        instance_fleet_type=tasks.EmrCreateCluster.InstanceRoleType.MASTER,
+                        instance_type_configs=[tasks.EmrCreateCluster.InstanceTypeConfigProperty(
+                            instance_type="m5.xlarge"
+                        )
+                        ],
+                        target_on_demand_capacity=1
+                    )
+                    ]
+                ),
+                name="ClusterName",
+                release_label="emr-7.9.0",
+                managed_scaling_policy=tasks.EmrCreateCluster.ManagedScalingPolicyProperty(
+                    compute_limits=tasks.EmrCreateCluster.ManagedScalingComputeLimitsProperty(
+                        unit_type=tasks.EmrCreateCluster.ComputeLimitsUnitType.INSTANCE_FLEET_UNITS,
+                        maximum_capacity_units=4,
+                        minimum_capacity_units=1,
+                        maximum_on_demand_capacity_units=4,
+                        maximum_core_capacity_units=2
+                    )
+                )
+            )
+        '''
+
+        INSTANCE_FLEET_UNITS = "INSTANCE_FLEET_UNITS"
+        '''InstanceFleetUnits.'''
+        INSTANCES = "INSTANCES"
+        '''Instances.'''
+        VCPU = "VCPU"
+        '''VCPU.'''
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.EmrCreateCluster.ConfigurationProperty",
         jsii_struct_bases=[],
@@ -42466,34 +43681,36 @@ class EmrCreateCluster(
 
             Example::
 
-                cluster_role = iam.Role(self, "ClusterRole",
-                    assumed_by=iam.ServicePrincipal("ec2.amazonaws.com")
-                )
-                
-                service_role = iam.Role(self, "ServiceRole",
-                    assumed_by=iam.ServicePrincipal("elasticmapreduce.amazonaws.com")
-                )
-                
-                auto_scaling_role = iam.Role(self, "AutoScalingRole",
-                    assumed_by=iam.ServicePrincipal("elasticmapreduce.amazonaws.com")
-                )
-                
-                auto_scaling_role.assume_role_policy.add_statements(
-                    iam.PolicyStatement(
-                        effect=iam.Effect.ALLOW,
-                        principals=[
-                            iam.ServicePrincipal("application-autoscaling.amazonaws.com")
-                        ],
-                        actions=["sts:AssumeRole"
+                tasks.EmrCreateCluster(self, "CreateCluster",
+                    instances=tasks.EmrCreateCluster.InstancesConfigProperty(
+                        instance_fleets=[tasks.EmrCreateCluster.InstanceFleetConfigProperty(
+                            instance_fleet_type=tasks.EmrCreateCluster.InstanceRoleType.CORE,
+                            instance_type_configs=[tasks.EmrCreateCluster.InstanceTypeConfigProperty(
+                                instance_type="m5.xlarge"
+                            )
+                            ],
+                            target_on_demand_capacity=1
+                        ), tasks.EmrCreateCluster.InstanceFleetConfigProperty(
+                            instance_fleet_type=tasks.EmrCreateCluster.InstanceRoleType.MASTER,
+                            instance_type_configs=[tasks.EmrCreateCluster.InstanceTypeConfigProperty(
+                                instance_type="m5.xlarge"
+                            )
+                            ],
+                            target_on_demand_capacity=1
+                        )
                         ]
-                    ))
-                
-                tasks.EmrCreateCluster(self, "Create Cluster",
-                    instances=tasks.EmrCreateCluster.InstancesConfigProperty(),
-                    cluster_role=cluster_role,
-                    name=sfn.TaskInput.from_json_path_at("$.ClusterName").value,
-                    service_role=service_role,
-                    auto_scaling_role=auto_scaling_role
+                    ),
+                    name="ClusterName",
+                    release_label="emr-7.9.0",
+                    managed_scaling_policy=tasks.EmrCreateCluster.ManagedScalingPolicyProperty(
+                        compute_limits=tasks.EmrCreateCluster.ManagedScalingComputeLimitsProperty(
+                            unit_type=tasks.EmrCreateCluster.ComputeLimitsUnitType.INSTANCE_FLEET_UNITS,
+                            maximum_capacity_units=4,
+                            minimum_capacity_units=1,
+                            maximum_on_demand_capacity_units=4,
+                            maximum_core_capacity_units=2
+                        )
+                    )
                 )
             '''
             if isinstance(placement, dict):
@@ -42855,6 +44072,222 @@ class EmrCreateCluster(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.EmrCreateCluster.ManagedScalingComputeLimitsProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "maximum_capacity_units": "maximumCapacityUnits",
+            "minimum_capacity_units": "minimumCapacityUnits",
+            "unit_type": "unitType",
+            "maximum_core_capacity_units": "maximumCoreCapacityUnits",
+            "maximum_on_demand_capacity_units": "maximumOnDemandCapacityUnits",
+        },
+    )
+    class ManagedScalingComputeLimitsProperty:
+        def __init__(
+            self,
+            *,
+            maximum_capacity_units: jsii.Number,
+            minimum_capacity_units: jsii.Number,
+            unit_type: "EmrCreateCluster.ComputeLimitsUnitType",
+            maximum_core_capacity_units: typing.Optional[jsii.Number] = None,
+            maximum_on_demand_capacity_units: typing.Optional[jsii.Number] = None,
+        ) -> None:
+            '''The EC2 unit limits for a managed scaling policy.
+
+            :param maximum_capacity_units: The upper boundary of Amazon EC2 units.
+            :param minimum_capacity_units: The lower boundary of Amazon EC2 units.
+            :param unit_type: The unit type used for specifying a managed scaling policy.
+            :param maximum_core_capacity_units: The upper boundary of Amazon EC2 units for core node type in a cluster. Default: - None
+            :param maximum_on_demand_capacity_units: The upper boundary of On-Demand Amazon EC2 units. Default: - None
+
+            :see: https://docs.aws.amazon.com/emr/latest/APIReference/API_ComputeLimits.html
+            :exampleMetadata: infused
+
+            Example::
+
+                tasks.EmrCreateCluster(self, "CreateCluster",
+                    instances=tasks.EmrCreateCluster.InstancesConfigProperty(
+                        instance_fleets=[tasks.EmrCreateCluster.InstanceFleetConfigProperty(
+                            instance_fleet_type=tasks.EmrCreateCluster.InstanceRoleType.CORE,
+                            instance_type_configs=[tasks.EmrCreateCluster.InstanceTypeConfigProperty(
+                                instance_type="m5.xlarge"
+                            )
+                            ],
+                            target_on_demand_capacity=1
+                        ), tasks.EmrCreateCluster.InstanceFleetConfigProperty(
+                            instance_fleet_type=tasks.EmrCreateCluster.InstanceRoleType.MASTER,
+                            instance_type_configs=[tasks.EmrCreateCluster.InstanceTypeConfigProperty(
+                                instance_type="m5.xlarge"
+                            )
+                            ],
+                            target_on_demand_capacity=1
+                        )
+                        ]
+                    ),
+                    name="ClusterName",
+                    release_label="emr-7.9.0",
+                    managed_scaling_policy=tasks.EmrCreateCluster.ManagedScalingPolicyProperty(
+                        compute_limits=tasks.EmrCreateCluster.ManagedScalingComputeLimitsProperty(
+                            unit_type=tasks.EmrCreateCluster.ComputeLimitsUnitType.INSTANCE_FLEET_UNITS,
+                            maximum_capacity_units=4,
+                            minimum_capacity_units=1,
+                            maximum_on_demand_capacity_units=4,
+                            maximum_core_capacity_units=2
+                        )
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__456056f16dcf97fd1f56ad4f544f9e6a7740b916af0bb528c7039258390c676c)
+                check_type(argname="argument maximum_capacity_units", value=maximum_capacity_units, expected_type=type_hints["maximum_capacity_units"])
+                check_type(argname="argument minimum_capacity_units", value=minimum_capacity_units, expected_type=type_hints["minimum_capacity_units"])
+                check_type(argname="argument unit_type", value=unit_type, expected_type=type_hints["unit_type"])
+                check_type(argname="argument maximum_core_capacity_units", value=maximum_core_capacity_units, expected_type=type_hints["maximum_core_capacity_units"])
+                check_type(argname="argument maximum_on_demand_capacity_units", value=maximum_on_demand_capacity_units, expected_type=type_hints["maximum_on_demand_capacity_units"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "maximum_capacity_units": maximum_capacity_units,
+                "minimum_capacity_units": minimum_capacity_units,
+                "unit_type": unit_type,
+            }
+            if maximum_core_capacity_units is not None:
+                self._values["maximum_core_capacity_units"] = maximum_core_capacity_units
+            if maximum_on_demand_capacity_units is not None:
+                self._values["maximum_on_demand_capacity_units"] = maximum_on_demand_capacity_units
+
+        @builtins.property
+        def maximum_capacity_units(self) -> jsii.Number:
+            '''The upper boundary of Amazon EC2 units.'''
+            result = self._values.get("maximum_capacity_units")
+            assert result is not None, "Required property 'maximum_capacity_units' is missing"
+            return typing.cast(jsii.Number, result)
+
+        @builtins.property
+        def minimum_capacity_units(self) -> jsii.Number:
+            '''The lower boundary of Amazon EC2 units.'''
+            result = self._values.get("minimum_capacity_units")
+            assert result is not None, "Required property 'minimum_capacity_units' is missing"
+            return typing.cast(jsii.Number, result)
+
+        @builtins.property
+        def unit_type(self) -> "EmrCreateCluster.ComputeLimitsUnitType":
+            '''The unit type used for specifying a managed scaling policy.'''
+            result = self._values.get("unit_type")
+            assert result is not None, "Required property 'unit_type' is missing"
+            return typing.cast("EmrCreateCluster.ComputeLimitsUnitType", result)
+
+        @builtins.property
+        def maximum_core_capacity_units(self) -> typing.Optional[jsii.Number]:
+            '''The upper boundary of Amazon EC2 units for core node type in a cluster.
+
+            :default: - None
+            '''
+            result = self._values.get("maximum_core_capacity_units")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def maximum_on_demand_capacity_units(self) -> typing.Optional[jsii.Number]:
+            '''The upper boundary of On-Demand Amazon EC2 units.
+
+            :default: - None
+            '''
+            result = self._values.get("maximum_on_demand_capacity_units")
+            return typing.cast(typing.Optional[jsii.Number], 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 "ManagedScalingComputeLimitsProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.EmrCreateCluster.ManagedScalingPolicyProperty",
+        jsii_struct_bases=[],
+        name_mapping={"compute_limits": "computeLimits"},
+    )
+    class ManagedScalingPolicyProperty:
+        def __init__(
+            self,
+            *,
+            compute_limits: typing.Optional[typing.Union["EmrCreateCluster.ManagedScalingComputeLimitsProperty", typing.Dict[builtins.str, typing.Any]]] = None,
+        ) -> None:
+            '''The managed scaling policy for an Amazon EMR cluster.
+
+            :param compute_limits: The Amazon EC2 unit limits for a managed scaling policy. Default: - None
+
+            :see: https://docs.aws.amazon.com/emr/latest/APIReference/API_ManagedScalingPolicy.html
+            :exampleMetadata: infused
+
+            Example::
+
+                tasks.EmrCreateCluster(self, "CreateCluster",
+                    instances=tasks.EmrCreateCluster.InstancesConfigProperty(
+                        instance_fleets=[tasks.EmrCreateCluster.InstanceFleetConfigProperty(
+                            instance_fleet_type=tasks.EmrCreateCluster.InstanceRoleType.CORE,
+                            instance_type_configs=[tasks.EmrCreateCluster.InstanceTypeConfigProperty(
+                                instance_type="m5.xlarge"
+                            )
+                            ],
+                            target_on_demand_capacity=1
+                        ), tasks.EmrCreateCluster.InstanceFleetConfigProperty(
+                            instance_fleet_type=tasks.EmrCreateCluster.InstanceRoleType.MASTER,
+                            instance_type_configs=[tasks.EmrCreateCluster.InstanceTypeConfigProperty(
+                                instance_type="m5.xlarge"
+                            )
+                            ],
+                            target_on_demand_capacity=1
+                        )
+                        ]
+                    ),
+                    name="ClusterName",
+                    release_label="emr-7.9.0",
+                    managed_scaling_policy=tasks.EmrCreateCluster.ManagedScalingPolicyProperty(
+                        compute_limits=tasks.EmrCreateCluster.ManagedScalingComputeLimitsProperty(
+                            unit_type=tasks.EmrCreateCluster.ComputeLimitsUnitType.INSTANCE_FLEET_UNITS,
+                            maximum_capacity_units=4,
+                            minimum_capacity_units=1,
+                            maximum_on_demand_capacity_units=4,
+                            maximum_core_capacity_units=2
+                        )
+                    )
+                )
+            '''
+            if isinstance(compute_limits, dict):
+                compute_limits = EmrCreateCluster.ManagedScalingComputeLimitsProperty(**compute_limits)
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__179ad22f7f4bb419f4267ee887aae9d8eb939feb472f44c905e5f5d18bca8899)
+                check_type(argname="argument compute_limits", value=compute_limits, expected_type=type_hints["compute_limits"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if compute_limits is not None:
+                self._values["compute_limits"] = compute_limits
+
+        @builtins.property
+        def compute_limits(
+            self,
+        ) -> typing.Optional["EmrCreateCluster.ManagedScalingComputeLimitsProperty"]:
+            '''The Amazon EC2 unit limits for a managed scaling policy.
+
+            :default: - None
+            '''
+            result = self._values.get("compute_limits")
+            return typing.cast(typing.Optional["EmrCreateCluster.ManagedScalingComputeLimitsProperty"], 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 "ManagedScalingPolicyProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.EmrCreateCluster.MetricDimensionProperty",
         jsii_struct_bases=[],
@@ -44077,9 +45510,12 @@ class EmrCreateCluster(
         "cluster_role": "clusterRole",
         "configurations": "configurations",
         "custom_ami_id": "customAmiId",
+        "ebs_root_volume_iops": "ebsRootVolumeIops",
         "ebs_root_volume_size": "ebsRootVolumeSize",
+        "ebs_root_volume_throughput": "ebsRootVolumeThroughput",
         "kerberos_attributes": "kerberosAttributes",
         "log_uri": "logUri",
+        "managed_scaling_policy": "managedScalingPolicy",
         "release_label": "releaseLabel",
         "scale_down_behavior": "scaleDownBehavior",
         "security_configuration": "securityConfiguration",
@@ -44117,9 +45553,12 @@ class EmrCreateClusterJsonPathProps(_TaskStateJsonPathBaseProps_57dc2260):
         cluster_role: typing.Optional[_IRole_235f5d8e] = None,
         configurations: typing.Optional[typing.Sequence[typing.Union[EmrCreateCluster.ConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         custom_ami_id: typing.Optional[builtins.str] = None,
+        ebs_root_volume_iops: typing.Optional[jsii.Number] = None,
         ebs_root_volume_size: typing.Optional[_Size_7b441c34] = None,
+        ebs_root_volume_throughput: typing.Optional[jsii.Number] = None,
         kerberos_attributes: typing.Optional[typing.Union[EmrCreateCluster.KerberosAttributesProperty, typing.Dict[builtins.str, typing.Any]]] = None,
         log_uri: typing.Optional[builtins.str] = None,
+        managed_scaling_policy: typing.Optional[typing.Union[EmrCreateCluster.ManagedScalingPolicyProperty, typing.Dict[builtins.str, typing.Any]]] = None,
         release_label: typing.Optional[builtins.str] = None,
         scale_down_behavior: typing.Optional[EmrCreateCluster.EmrClusterScaleDownBehavior] = None,
         security_configuration: typing.Optional[builtins.str] = None,
@@ -44154,9 +45593,12 @@ class EmrCreateClusterJsonPathProps(_TaskStateJsonPathBaseProps_57dc2260):
         :param cluster_role: Also called instance profile and EC2 role. An IAM role for an EMR cluster. The EC2 instances of the cluster assume this role. This attribute has been renamed from jobFlowRole to clusterRole to align with other ERM/StepFunction integration parameters. Default: - - A Role will be created
         :param configurations: The list of configurations supplied for the EMR cluster you are creating. Default: - None
         :param custom_ami_id: The ID of a custom Amazon EBS-backed Linux AMI. Default: - None
+        :param ebs_root_volume_iops: The IOPS of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Requires EMR release label 6.15.0 or above. Must be in range [3000, 16000]. Default: - EMR selected default
         :param ebs_root_volume_size: The size of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Default: - EMR selected default
+        :param ebs_root_volume_throughput: The throughput, in MiB/s, of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Requires EMR release label 6.15.0 or above. Must be in range [125, 1000]. Default: - EMR selected default
         :param kerberos_attributes: Attributes for Kerberos configuration when Kerberos authentication is enabled using a security configuration. Default: - None
         :param log_uri: The location in Amazon S3 to write the log files of the job flow. Default: - None
+        :param managed_scaling_policy: The specified managed scaling policy for an Amazon EMR cluster. Default: - None
         :param release_label: The Amazon EMR release label, which determines the version of open-source application packages installed on the cluster. Default: - EMR selected default
         :param scale_down_behavior: Specifies the way that individual Amazon EC2 instances terminate when an automatic scale-in activity occurs or an instance group is resized. Default: - EMR selected default
         :param security_configuration: The name of a security configuration to apply to the cluster. Default: - None
@@ -44371,7 +45813,9 @@ class EmrCreateClusterJsonPathProps(_TaskStateJsonPathBaseProps_57dc2260):
                     role=task_role
                 ),
                 custom_ami_id="customAmiId",
+                ebs_root_volume_iops=123,
                 ebs_root_volume_size=size,
+                ebs_root_volume_throughput=123,
                 heartbeat=cdk.Duration.minutes(30),
                 heartbeat_timeout=timeout,
                 input_path="inputPath",
@@ -44386,6 +45830,17 @@ class EmrCreateClusterJsonPathProps(_TaskStateJsonPathBaseProps_57dc2260):
                     kdc_admin_password="kdcAdminPassword"
                 ),
                 log_uri="logUri",
+                managed_scaling_policy=stepfunctions_tasks.EmrCreateCluster.ManagedScalingPolicyProperty(
+                    compute_limits=stepfunctions_tasks.EmrCreateCluster.ManagedScalingComputeLimitsProperty(
+                        maximum_capacity_units=123,
+                        minimum_capacity_units=123,
+                        unit_type=stepfunctions_tasks.EmrCreateCluster.ComputeLimitsUnitType.INSTANCE_FLEET_UNITS,
+            
+                        # the properties below are optional
+                        maximum_core_capacity_units=123,
+                        maximum_on_demand_capacity_units=123
+                    )
+                ),
                 output_path="outputPath",
                 query_language=stepfunctions.QueryLanguage.JSON_PATH,
                 release_label="releaseLabel",
@@ -44412,6 +45867,8 @@ class EmrCreateClusterJsonPathProps(_TaskStateJsonPathBaseProps_57dc2260):
             instances = EmrCreateCluster.InstancesConfigProperty(**instances)
         if isinstance(kerberos_attributes, dict):
             kerberos_attributes = EmrCreateCluster.KerberosAttributesProperty(**kerberos_attributes)
+        if isinstance(managed_scaling_policy, dict):
+            managed_scaling_policy = EmrCreateCluster.ManagedScalingPolicyProperty(**managed_scaling_policy)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__8eee079f7d9817361a59216197eaa0f6c6e38fddbd968457fbb263e4251c422a)
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
@@ -44438,9 +45895,12 @@ class EmrCreateClusterJsonPathProps(_TaskStateJsonPathBaseProps_57dc2260):
             check_type(argname="argument cluster_role", value=cluster_role, expected_type=type_hints["cluster_role"])
             check_type(argname="argument configurations", value=configurations, expected_type=type_hints["configurations"])
             check_type(argname="argument custom_ami_id", value=custom_ami_id, expected_type=type_hints["custom_ami_id"])
+            check_type(argname="argument ebs_root_volume_iops", value=ebs_root_volume_iops, expected_type=type_hints["ebs_root_volume_iops"])
             check_type(argname="argument ebs_root_volume_size", value=ebs_root_volume_size, expected_type=type_hints["ebs_root_volume_size"])
+            check_type(argname="argument ebs_root_volume_throughput", value=ebs_root_volume_throughput, expected_type=type_hints["ebs_root_volume_throughput"])
             check_type(argname="argument kerberos_attributes", value=kerberos_attributes, expected_type=type_hints["kerberos_attributes"])
             check_type(argname="argument log_uri", value=log_uri, expected_type=type_hints["log_uri"])
+            check_type(argname="argument managed_scaling_policy", value=managed_scaling_policy, expected_type=type_hints["managed_scaling_policy"])
             check_type(argname="argument release_label", value=release_label, expected_type=type_hints["release_label"])
             check_type(argname="argument scale_down_behavior", value=scale_down_behavior, expected_type=type_hints["scale_down_behavior"])
             check_type(argname="argument security_configuration", value=security_configuration, expected_type=type_hints["security_configuration"])
@@ -44496,12 +45956,18 @@ class EmrCreateClusterJsonPathProps(_TaskStateJsonPathBaseProps_57dc2260):
             self._values["configurations"] = configurations
         if custom_ami_id is not None:
             self._values["custom_ami_id"] = custom_ami_id
+        if ebs_root_volume_iops is not None:
+            self._values["ebs_root_volume_iops"] = ebs_root_volume_iops
         if ebs_root_volume_size is not None:
             self._values["ebs_root_volume_size"] = ebs_root_volume_size
+        if ebs_root_volume_throughput is not None:
+            self._values["ebs_root_volume_throughput"] = ebs_root_volume_throughput
         if kerberos_attributes is not None:
             self._values["kerberos_attributes"] = kerberos_attributes
         if log_uri is not None:
             self._values["log_uri"] = log_uri
+        if managed_scaling_policy is not None:
+            self._values["managed_scaling_policy"] = managed_scaling_policy
         if release_label is not None:
             self._values["release_label"] = release_label
         if scale_down_behavior is not None:
@@ -44797,6 +46263,20 @@ class EmrCreateClusterJsonPathProps(_TaskStateJsonPathBaseProps_57dc2260):
         result = self._values.get("custom_ami_id")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def ebs_root_volume_iops(self) -> typing.Optional[jsii.Number]:
+        '''The IOPS of the EBS root device volume of the Linux AMI that is used for each EC2 instance.
+
+        Requires EMR release label 6.15.0 or above.
+        Must be in range [3000, 16000].
+
+        :default: - EMR selected default
+
+        :see: https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-custom-ami-root-volume-size.html#emr-root-volume-overview
+        '''
+        result = self._values.get("ebs_root_volume_iops")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def ebs_root_volume_size(self) -> typing.Optional[_Size_7b441c34]:
         '''The size of the EBS root device volume of the Linux AMI that is used for each EC2 instance.
@@ -44806,6 +46286,20 @@ class EmrCreateClusterJsonPathProps(_TaskStateJsonPathBaseProps_57dc2260):
         result = self._values.get("ebs_root_volume_size")
         return typing.cast(typing.Optional[_Size_7b441c34], result)
 
+    @builtins.property
+    def ebs_root_volume_throughput(self) -> typing.Optional[jsii.Number]:
+        '''The throughput, in MiB/s, of the EBS root device volume of the Linux AMI that is used for each EC2 instance.
+
+        Requires EMR release label 6.15.0 or above.
+        Must be in range [125, 1000].
+
+        :default: - EMR selected default
+
+        :see: https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-custom-ami-root-volume-size.html#emr-root-volume-overview
+        '''
+        result = self._values.get("ebs_root_volume_throughput")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def kerberos_attributes(
         self,
@@ -44826,6 +46320,17 @@ class EmrCreateClusterJsonPathProps(_TaskStateJsonPathBaseProps_57dc2260):
         result = self._values.get("log_uri")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def managed_scaling_policy(
+        self,
+    ) -> typing.Optional[EmrCreateCluster.ManagedScalingPolicyProperty]:
+        '''The specified managed scaling policy for an Amazon EMR cluster.
+
+        :default: - None
+        '''
+        result = self._values.get("managed_scaling_policy")
+        return typing.cast(typing.Optional[EmrCreateCluster.ManagedScalingPolicyProperty], result)
+
     @builtins.property
     def release_label(self) -> typing.Optional[builtins.str]:
         '''The Amazon EMR release label, which determines the version of open-source application packages installed on the cluster.
@@ -44931,9 +46436,12 @@ class EmrCreateClusterJsonPathProps(_TaskStateJsonPathBaseProps_57dc2260):
         "cluster_role": "clusterRole",
         "configurations": "configurations",
         "custom_ami_id": "customAmiId",
+        "ebs_root_volume_iops": "ebsRootVolumeIops",
         "ebs_root_volume_size": "ebsRootVolumeSize",
+        "ebs_root_volume_throughput": "ebsRootVolumeThroughput",
         "kerberos_attributes": "kerberosAttributes",
         "log_uri": "logUri",
+        "managed_scaling_policy": "managedScalingPolicy",
         "release_label": "releaseLabel",
         "scale_down_behavior": "scaleDownBehavior",
         "security_configuration": "securityConfiguration",
@@ -44968,9 +46476,12 @@ class EmrCreateClusterJsonataProps(_TaskStateJsonataBaseProps_0e91775c):
         cluster_role: typing.Optional[_IRole_235f5d8e] = None,
         configurations: typing.Optional[typing.Sequence[typing.Union[EmrCreateCluster.ConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         custom_ami_id: typing.Optional[builtins.str] = None,
+        ebs_root_volume_iops: typing.Optional[jsii.Number] = None,
         ebs_root_volume_size: typing.Optional[_Size_7b441c34] = None,
+        ebs_root_volume_throughput: typing.Optional[jsii.Number] = None,
         kerberos_attributes: typing.Optional[typing.Union[EmrCreateCluster.KerberosAttributesProperty, typing.Dict[builtins.str, typing.Any]]] = None,
         log_uri: typing.Optional[builtins.str] = None,
+        managed_scaling_policy: typing.Optional[typing.Union[EmrCreateCluster.ManagedScalingPolicyProperty, typing.Dict[builtins.str, typing.Any]]] = None,
         release_label: typing.Optional[builtins.str] = None,
         scale_down_behavior: typing.Optional[EmrCreateCluster.EmrClusterScaleDownBehavior] = None,
         security_configuration: typing.Optional[builtins.str] = None,
@@ -45002,9 +46513,12 @@ class EmrCreateClusterJsonataProps(_TaskStateJsonataBaseProps_0e91775c):
         :param cluster_role: Also called instance profile and EC2 role. An IAM role for an EMR cluster. The EC2 instances of the cluster assume this role. This attribute has been renamed from jobFlowRole to clusterRole to align with other ERM/StepFunction integration parameters. Default: - - A Role will be created
         :param configurations: The list of configurations supplied for the EMR cluster you are creating. Default: - None
         :param custom_ami_id: The ID of a custom Amazon EBS-backed Linux AMI. Default: - None
+        :param ebs_root_volume_iops: The IOPS of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Requires EMR release label 6.15.0 or above. Must be in range [3000, 16000]. Default: - EMR selected default
         :param ebs_root_volume_size: The size of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Default: - EMR selected default
+        :param ebs_root_volume_throughput: The throughput, in MiB/s, of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Requires EMR release label 6.15.0 or above. Must be in range [125, 1000]. Default: - EMR selected default
         :param kerberos_attributes: Attributes for Kerberos configuration when Kerberos authentication is enabled using a security configuration. Default: - None
         :param log_uri: The location in Amazon S3 to write the log files of the job flow. Default: - None
+        :param managed_scaling_policy: The specified managed scaling policy for an Amazon EMR cluster. Default: - None
         :param release_label: The Amazon EMR release label, which determines the version of open-source application packages installed on the cluster. Default: - EMR selected default
         :param scale_down_behavior: Specifies the way that individual Amazon EC2 instances terminate when an automatic scale-in activity occurs or an instance group is resized. Default: - EMR selected default
         :param security_configuration: The name of a security configuration to apply to the cluster. Default: - None
@@ -45219,7 +46733,9 @@ class EmrCreateClusterJsonataProps(_TaskStateJsonataBaseProps_0e91775c):
                     role=task_role
                 ),
                 custom_ami_id="customAmiId",
+                ebs_root_volume_iops=123,
                 ebs_root_volume_size=size,
+                ebs_root_volume_throughput=123,
                 heartbeat=cdk.Duration.minutes(30),
                 heartbeat_timeout=timeout,
                 integration_pattern=stepfunctions.IntegrationPattern.REQUEST_RESPONSE,
@@ -45233,6 +46749,17 @@ class EmrCreateClusterJsonataProps(_TaskStateJsonataBaseProps_0e91775c):
                     kdc_admin_password="kdcAdminPassword"
                 ),
                 log_uri="logUri",
+                managed_scaling_policy=stepfunctions_tasks.EmrCreateCluster.ManagedScalingPolicyProperty(
+                    compute_limits=stepfunctions_tasks.EmrCreateCluster.ManagedScalingComputeLimitsProperty(
+                        maximum_capacity_units=123,
+                        minimum_capacity_units=123,
+                        unit_type=stepfunctions_tasks.EmrCreateCluster.ComputeLimitsUnitType.INSTANCE_FLEET_UNITS,
+            
+                        # the properties below are optional
+                        maximum_core_capacity_units=123,
+                        maximum_on_demand_capacity_units=123
+                    )
+                ),
                 outputs=outputs,
                 query_language=stepfunctions.QueryLanguage.JSON_PATH,
                 release_label="releaseLabel",
@@ -45255,6 +46782,8 @@ class EmrCreateClusterJsonataProps(_TaskStateJsonataBaseProps_0e91775c):
             instances = EmrCreateCluster.InstancesConfigProperty(**instances)
         if isinstance(kerberos_attributes, dict):
             kerberos_attributes = EmrCreateCluster.KerberosAttributesProperty(**kerberos_attributes)
+        if isinstance(managed_scaling_policy, dict):
+            managed_scaling_policy = EmrCreateCluster.ManagedScalingPolicyProperty(**managed_scaling_policy)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__e0198d308a9f96d3aadda143c9d8a0ef5848603e760f6a16d02390d989c574d3)
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
@@ -45278,9 +46807,12 @@ class EmrCreateClusterJsonataProps(_TaskStateJsonataBaseProps_0e91775c):
             check_type(argname="argument cluster_role", value=cluster_role, expected_type=type_hints["cluster_role"])
             check_type(argname="argument configurations", value=configurations, expected_type=type_hints["configurations"])
             check_type(argname="argument custom_ami_id", value=custom_ami_id, expected_type=type_hints["custom_ami_id"])
+            check_type(argname="argument ebs_root_volume_iops", value=ebs_root_volume_iops, expected_type=type_hints["ebs_root_volume_iops"])
             check_type(argname="argument ebs_root_volume_size", value=ebs_root_volume_size, expected_type=type_hints["ebs_root_volume_size"])
+            check_type(argname="argument ebs_root_volume_throughput", value=ebs_root_volume_throughput, expected_type=type_hints["ebs_root_volume_throughput"])
             check_type(argname="argument kerberos_attributes", value=kerberos_attributes, expected_type=type_hints["kerberos_attributes"])
             check_type(argname="argument log_uri", value=log_uri, expected_type=type_hints["log_uri"])
+            check_type(argname="argument managed_scaling_policy", value=managed_scaling_policy, expected_type=type_hints["managed_scaling_policy"])
             check_type(argname="argument release_label", value=release_label, expected_type=type_hints["release_label"])
             check_type(argname="argument scale_down_behavior", value=scale_down_behavior, expected_type=type_hints["scale_down_behavior"])
             check_type(argname="argument security_configuration", value=security_configuration, expected_type=type_hints["security_configuration"])
@@ -45330,12 +46862,18 @@ class EmrCreateClusterJsonataProps(_TaskStateJsonataBaseProps_0e91775c):
             self._values["configurations"] = configurations
         if custom_ami_id is not None:
             self._values["custom_ami_id"] = custom_ami_id
+        if ebs_root_volume_iops is not None:
+            self._values["ebs_root_volume_iops"] = ebs_root_volume_iops
         if ebs_root_volume_size is not None:
             self._values["ebs_root_volume_size"] = ebs_root_volume_size
+        if ebs_root_volume_throughput is not None:
+            self._values["ebs_root_volume_throughput"] = ebs_root_volume_throughput
         if kerberos_attributes is not None:
             self._values["kerberos_attributes"] = kerberos_attributes
         if log_uri is not None:
             self._values["log_uri"] = log_uri
+        if managed_scaling_policy is not None:
+            self._values["managed_scaling_policy"] = managed_scaling_policy
         if release_label is not None:
             self._values["release_label"] = release_label
         if scale_down_behavior is not None:
@@ -45596,6 +47134,20 @@ class EmrCreateClusterJsonataProps(_TaskStateJsonataBaseProps_0e91775c):
         result = self._values.get("custom_ami_id")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def ebs_root_volume_iops(self) -> typing.Optional[jsii.Number]:
+        '''The IOPS of the EBS root device volume of the Linux AMI that is used for each EC2 instance.
+
+        Requires EMR release label 6.15.0 or above.
+        Must be in range [3000, 16000].
+
+        :default: - EMR selected default
+
+        :see: https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-custom-ami-root-volume-size.html#emr-root-volume-overview
+        '''
+        result = self._values.get("ebs_root_volume_iops")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def ebs_root_volume_size(self) -> typing.Optional[_Size_7b441c34]:
         '''The size of the EBS root device volume of the Linux AMI that is used for each EC2 instance.
@@ -45605,6 +47157,20 @@ class EmrCreateClusterJsonataProps(_TaskStateJsonataBaseProps_0e91775c):
         result = self._values.get("ebs_root_volume_size")
         return typing.cast(typing.Optional[_Size_7b441c34], result)
 
+    @builtins.property
+    def ebs_root_volume_throughput(self) -> typing.Optional[jsii.Number]:
+        '''The throughput, in MiB/s, of the EBS root device volume of the Linux AMI that is used for each EC2 instance.
+
+        Requires EMR release label 6.15.0 or above.
+        Must be in range [125, 1000].
+
+        :default: - EMR selected default
+
+        :see: https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-custom-ami-root-volume-size.html#emr-root-volume-overview
+        '''
+        result = self._values.get("ebs_root_volume_throughput")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def kerberos_attributes(
         self,
@@ -45625,6 +47191,17 @@ class EmrCreateClusterJsonataProps(_TaskStateJsonataBaseProps_0e91775c):
         result = self._values.get("log_uri")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def managed_scaling_policy(
+        self,
+    ) -> typing.Optional[EmrCreateCluster.ManagedScalingPolicyProperty]:
+        '''The specified managed scaling policy for an Amazon EMR cluster.
+
+        :default: - None
+        '''
+        result = self._values.get("managed_scaling_policy")
+        return typing.cast(typing.Optional[EmrCreateCluster.ManagedScalingPolicyProperty], result)
+
     @builtins.property
     def release_label(self) -> typing.Optional[builtins.str]:
         '''The Amazon EMR release label, which determines the version of open-source application packages installed on the cluster.
@@ -45734,9 +47311,12 @@ class EmrCreateClusterJsonataProps(_TaskStateJsonataBaseProps_0e91775c):
         "cluster_role": "clusterRole",
         "configurations": "configurations",
         "custom_ami_id": "customAmiId",
+        "ebs_root_volume_iops": "ebsRootVolumeIops",
         "ebs_root_volume_size": "ebsRootVolumeSize",
+        "ebs_root_volume_throughput": "ebsRootVolumeThroughput",
         "kerberos_attributes": "kerberosAttributes",
         "log_uri": "logUri",
+        "managed_scaling_policy": "managedScalingPolicy",
         "release_label": "releaseLabel",
         "scale_down_behavior": "scaleDownBehavior",
         "security_configuration": "securityConfiguration",
@@ -45775,9 +47355,12 @@ class EmrCreateClusterProps(_TaskStateBaseProps_3a62b6d0):
         cluster_role: typing.Optional[_IRole_235f5d8e] = None,
         configurations: typing.Optional[typing.Sequence[typing.Union[EmrCreateCluster.ConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         custom_ami_id: typing.Optional[builtins.str] = None,
+        ebs_root_volume_iops: typing.Optional[jsii.Number] = None,
         ebs_root_volume_size: typing.Optional[_Size_7b441c34] = None,
+        ebs_root_volume_throughput: typing.Optional[jsii.Number] = None,
         kerberos_attributes: typing.Optional[typing.Union[EmrCreateCluster.KerberosAttributesProperty, typing.Dict[builtins.str, typing.Any]]] = None,
         log_uri: typing.Optional[builtins.str] = None,
+        managed_scaling_policy: typing.Optional[typing.Union[EmrCreateCluster.ManagedScalingPolicyProperty, typing.Dict[builtins.str, typing.Any]]] = None,
         release_label: typing.Optional[builtins.str] = None,
         scale_down_behavior: typing.Optional[EmrCreateCluster.EmrClusterScaleDownBehavior] = None,
         security_configuration: typing.Optional[builtins.str] = None,
@@ -45813,9 +47396,12 @@ class EmrCreateClusterProps(_TaskStateBaseProps_3a62b6d0):
         :param cluster_role: Also called instance profile and EC2 role. An IAM role for an EMR cluster. The EC2 instances of the cluster assume this role. This attribute has been renamed from jobFlowRole to clusterRole to align with other ERM/StepFunction integration parameters. Default: - - A Role will be created
         :param configurations: The list of configurations supplied for the EMR cluster you are creating. Default: - None
         :param custom_ami_id: The ID of a custom Amazon EBS-backed Linux AMI. Default: - None
+        :param ebs_root_volume_iops: The IOPS of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Requires EMR release label 6.15.0 or above. Must be in range [3000, 16000]. Default: - EMR selected default
         :param ebs_root_volume_size: The size of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Default: - EMR selected default
+        :param ebs_root_volume_throughput: The throughput, in MiB/s, of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Requires EMR release label 6.15.0 or above. Must be in range [125, 1000]. Default: - EMR selected default
         :param kerberos_attributes: Attributes for Kerberos configuration when Kerberos authentication is enabled using a security configuration. Default: - None
         :param log_uri: The location in Amazon S3 to write the log files of the job flow. Default: - None
+        :param managed_scaling_policy: The specified managed scaling policy for an Amazon EMR cluster. Default: - None
         :param release_label: The Amazon EMR release label, which determines the version of open-source application packages installed on the cluster. Default: - EMR selected default
         :param scale_down_behavior: Specifies the way that individual Amazon EC2 instances terminate when an automatic scale-in activity occurs or an instance group is resized. Default: - EMR selected default
         :param security_configuration: The name of a security configuration to apply to the cluster. Default: - None
@@ -45828,34 +47414,36 @@ class EmrCreateClusterProps(_TaskStateBaseProps_3a62b6d0):
 
         Example::
 
-            cluster_role = iam.Role(self, "ClusterRole",
-                assumed_by=iam.ServicePrincipal("ec2.amazonaws.com")
-            )
-            
-            service_role = iam.Role(self, "ServiceRole",
-                assumed_by=iam.ServicePrincipal("elasticmapreduce.amazonaws.com")
-            )
-            
-            auto_scaling_role = iam.Role(self, "AutoScalingRole",
-                assumed_by=iam.ServicePrincipal("elasticmapreduce.amazonaws.com")
-            )
-            
-            auto_scaling_role.assume_role_policy.add_statements(
-                iam.PolicyStatement(
-                    effect=iam.Effect.ALLOW,
-                    principals=[
-                        iam.ServicePrincipal("application-autoscaling.amazonaws.com")
-                    ],
-                    actions=["sts:AssumeRole"
+            tasks.EmrCreateCluster(self, "CreateCluster",
+                instances=tasks.EmrCreateCluster.InstancesConfigProperty(
+                    instance_fleets=[tasks.EmrCreateCluster.InstanceFleetConfigProperty(
+                        instance_fleet_type=tasks.EmrCreateCluster.InstanceRoleType.CORE,
+                        instance_type_configs=[tasks.EmrCreateCluster.InstanceTypeConfigProperty(
+                            instance_type="m5.xlarge"
+                        )
+                        ],
+                        target_on_demand_capacity=1
+                    ), tasks.EmrCreateCluster.InstanceFleetConfigProperty(
+                        instance_fleet_type=tasks.EmrCreateCluster.InstanceRoleType.MASTER,
+                        instance_type_configs=[tasks.EmrCreateCluster.InstanceTypeConfigProperty(
+                            instance_type="m5.xlarge"
+                        )
+                        ],
+                        target_on_demand_capacity=1
+                    )
                     ]
-                ))
-            
-            tasks.EmrCreateCluster(self, "Create Cluster",
-                instances=tasks.EmrCreateCluster.InstancesConfigProperty(),
-                cluster_role=cluster_role,
-                name=sfn.TaskInput.from_json_path_at("$.ClusterName").value,
-                service_role=service_role,
-                auto_scaling_role=auto_scaling_role
+                ),
+                name="ClusterName",
+                release_label="emr-7.9.0",
+                managed_scaling_policy=tasks.EmrCreateCluster.ManagedScalingPolicyProperty(
+                    compute_limits=tasks.EmrCreateCluster.ManagedScalingComputeLimitsProperty(
+                        unit_type=tasks.EmrCreateCluster.ComputeLimitsUnitType.INSTANCE_FLEET_UNITS,
+                        maximum_capacity_units=4,
+                        minimum_capacity_units=1,
+                        maximum_on_demand_capacity_units=4,
+                        maximum_core_capacity_units=2
+                    )
+                )
             )
         '''
         if isinstance(credentials, dict):
@@ -45864,6 +47452,8 @@ class EmrCreateClusterProps(_TaskStateBaseProps_3a62b6d0):
             instances = EmrCreateCluster.InstancesConfigProperty(**instances)
         if isinstance(kerberos_attributes, dict):
             kerberos_attributes = EmrCreateCluster.KerberosAttributesProperty(**kerberos_attributes)
+        if isinstance(managed_scaling_policy, dict):
+            managed_scaling_policy = EmrCreateCluster.ManagedScalingPolicyProperty(**managed_scaling_policy)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__47264d4efff2249070476b1432ca851665096bb89026c6d6564ff3c77327b86c)
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
@@ -45891,9 +47481,12 @@ class EmrCreateClusterProps(_TaskStateBaseProps_3a62b6d0):
             check_type(argname="argument cluster_role", value=cluster_role, expected_type=type_hints["cluster_role"])
             check_type(argname="argument configurations", value=configurations, expected_type=type_hints["configurations"])
             check_type(argname="argument custom_ami_id", value=custom_ami_id, expected_type=type_hints["custom_ami_id"])
+            check_type(argname="argument ebs_root_volume_iops", value=ebs_root_volume_iops, expected_type=type_hints["ebs_root_volume_iops"])
             check_type(argname="argument ebs_root_volume_size", value=ebs_root_volume_size, expected_type=type_hints["ebs_root_volume_size"])
+            check_type(argname="argument ebs_root_volume_throughput", value=ebs_root_volume_throughput, expected_type=type_hints["ebs_root_volume_throughput"])
             check_type(argname="argument kerberos_attributes", value=kerberos_attributes, expected_type=type_hints["kerberos_attributes"])
             check_type(argname="argument log_uri", value=log_uri, expected_type=type_hints["log_uri"])
+            check_type(argname="argument managed_scaling_policy", value=managed_scaling_policy, expected_type=type_hints["managed_scaling_policy"])
             check_type(argname="argument release_label", value=release_label, expected_type=type_hints["release_label"])
             check_type(argname="argument scale_down_behavior", value=scale_down_behavior, expected_type=type_hints["scale_down_behavior"])
             check_type(argname="argument security_configuration", value=security_configuration, expected_type=type_hints["security_configuration"])
@@ -45951,12 +47544,18 @@ class EmrCreateClusterProps(_TaskStateBaseProps_3a62b6d0):
             self._values["configurations"] = configurations
         if custom_ami_id is not None:
             self._values["custom_ami_id"] = custom_ami_id
+        if ebs_root_volume_iops is not None:
+            self._values["ebs_root_volume_iops"] = ebs_root_volume_iops
         if ebs_root_volume_size is not None:
             self._values["ebs_root_volume_size"] = ebs_root_volume_size
+        if ebs_root_volume_throughput is not None:
+            self._values["ebs_root_volume_throughput"] = ebs_root_volume_throughput
         if kerberos_attributes is not None:
             self._values["kerberos_attributes"] = kerberos_attributes
         if log_uri is not None:
             self._values["log_uri"] = log_uri
+        if managed_scaling_policy is not None:
+            self._values["managed_scaling_policy"] = managed_scaling_policy
         if release_label is not None:
             self._values["release_label"] = release_label
         if scale_down_behavior is not None:
@@ -46269,6 +47868,20 @@ class EmrCreateClusterProps(_TaskStateBaseProps_3a62b6d0):
         result = self._values.get("custom_ami_id")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def ebs_root_volume_iops(self) -> typing.Optional[jsii.Number]:
+        '''The IOPS of the EBS root device volume of the Linux AMI that is used for each EC2 instance.
+
+        Requires EMR release label 6.15.0 or above.
+        Must be in range [3000, 16000].
+
+        :default: - EMR selected default
+
+        :see: https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-custom-ami-root-volume-size.html#emr-root-volume-overview
+        '''
+        result = self._values.get("ebs_root_volume_iops")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def ebs_root_volume_size(self) -> typing.Optional[_Size_7b441c34]:
         '''The size of the EBS root device volume of the Linux AMI that is used for each EC2 instance.
@@ -46278,6 +47891,20 @@ class EmrCreateClusterProps(_TaskStateBaseProps_3a62b6d0):
         result = self._values.get("ebs_root_volume_size")
         return typing.cast(typing.Optional[_Size_7b441c34], result)
 
+    @builtins.property
+    def ebs_root_volume_throughput(self) -> typing.Optional[jsii.Number]:
+        '''The throughput, in MiB/s, of the EBS root device volume of the Linux AMI that is used for each EC2 instance.
+
+        Requires EMR release label 6.15.0 or above.
+        Must be in range [125, 1000].
+
+        :default: - EMR selected default
+
+        :see: https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-custom-ami-root-volume-size.html#emr-root-volume-overview
+        '''
+        result = self._values.get("ebs_root_volume_throughput")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def kerberos_attributes(
         self,
@@ -46298,6 +47925,17 @@ class EmrCreateClusterProps(_TaskStateBaseProps_3a62b6d0):
         result = self._values.get("log_uri")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def managed_scaling_policy(
+        self,
+    ) -> typing.Optional[EmrCreateCluster.ManagedScalingPolicyProperty]:
+        '''The specified managed scaling policy for an Amazon EMR cluster.
+
+        :default: - None
+        '''
+        result = self._values.get("managed_scaling_policy")
+        return typing.cast(typing.Optional[EmrCreateCluster.ManagedScalingPolicyProperty], result)
+
     @builtins.property
     def release_label(self) -> typing.Optional[builtins.str]:
         '''The Amazon EMR release label, which determines the version of open-source application packages installed on the cluster.
@@ -52006,6 +53644,7 @@ class EvaluateExpression(
         id: builtins.str,
         *,
         expression: builtins.str,
+        architecture: typing.Optional[_Architecture_12d5a53f] = None,
         runtime: typing.Optional[_Runtime_b4eaa844] = None,
         result_path: typing.Optional[builtins.str] = None,
         result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
@@ -52027,6 +53666,7 @@ class EvaluateExpression(
         :param scope: -
         :param id: Descriptive identifier for this chainable.
         :param expression: The expression to evaluate. The expression may contain state paths. Example value: ``'$.a + $.b'``
+        :param architecture: The system architecture compatible with this lambda function. ARM64 architecture support varies by AWS region. Please verify that your deployment region supports Lambda functions with ARM64 architecture before specifying Architecture.ARM_64. Default: Architecture.X86_64
         :param runtime: The runtime language to use to evaluate the expression. Default: - the latest Lambda node runtime available in your region.
         :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: $
         :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
@@ -52050,6 +53690,7 @@ class EvaluateExpression(
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
         props = EvaluateExpressionProps(
             expression=expression,
+            architecture=architecture,
             runtime=runtime,
             result_path=result_path,
             result_selector=result_selector,
@@ -52101,6 +53742,7 @@ class EvaluateExpression(
         "result_path": "resultPath",
         "result_selector": "resultSelector",
         "expression": "expression",
+        "architecture": "architecture",
         "runtime": "runtime",
     },
 )
@@ -52124,6 +53766,7 @@ class EvaluateExpressionProps(_TaskStateBaseProps_3a62b6d0):
         result_path: typing.Optional[builtins.str] = None,
         result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
         expression: builtins.str,
+        architecture: typing.Optional[_Architecture_12d5a53f] = None,
         runtime: typing.Optional[_Runtime_b4eaa844] = None,
     ) -> None:
         '''Properties for EvaluateExpression.
@@ -52144,6 +53787,7 @@ class EvaluateExpressionProps(_TaskStateBaseProps_3a62b6d0):
         :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: $
         :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 expression: The expression to evaluate. The expression may contain state paths. Example value: ``'$.a + $.b'``
+        :param architecture: The system architecture compatible with this lambda function. ARM64 architecture support varies by AWS region. Please verify that your deployment region supports Lambda functions with ARM64 architecture before specifying Architecture.ARM_64. Default: Architecture.X86_64
         :param runtime: The runtime language to use to evaluate the expression. Default: - the latest Lambda node runtime available in your region.
 
         :exampleMetadata: infused
@@ -52196,6 +53840,7 @@ class EvaluateExpressionProps(_TaskStateBaseProps_3a62b6d0):
             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 expression", value=expression, expected_type=type_hints["expression"])
+            check_type(argname="argument architecture", value=architecture, expected_type=type_hints["architecture"])
             check_type(argname="argument runtime", value=runtime, expected_type=type_hints["runtime"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "expression": expression,
@@ -52230,6 +53875,8 @@ class EvaluateExpressionProps(_TaskStateBaseProps_3a62b6d0):
             self._values["result_path"] = result_path
         if result_selector is not None:
             self._values["result_selector"] = result_selector
+        if architecture is not None:
+            self._values["architecture"] = architecture
         if runtime is not None:
             self._values["runtime"] = runtime
 
@@ -52437,6 +54084,17 @@ class EvaluateExpressionProps(_TaskStateBaseProps_3a62b6d0):
         assert result is not None, "Required property 'expression' is missing"
         return typing.cast(builtins.str, result)
 
+    @builtins.property
+    def architecture(self) -> typing.Optional[_Architecture_12d5a53f]:
+        '''The system architecture compatible with this lambda function.
+
+        ARM64 architecture support varies by AWS region. Please verify that your deployment region supports Lambda functions with ARM64 architecture before specifying Architecture.ARM_64.
+
+        :default: Architecture.X86_64
+        '''
+        result = self._values.get("architecture")
+        return typing.cast(typing.Optional[_Architecture_12d5a53f], result)
+
     @builtins.property
     def runtime(self) -> typing.Optional[_Runtime_b4eaa844]:
         '''The runtime language to use to evaluate the expression.
@@ -61480,7 +63138,7 @@ class HttpInvokeProps(_TaskStateBaseProps_3a62b6d0):
             
             tasks.HttpInvoke(self, "Invoke HTTP API",
                 api_root="https://api.example.com",
-                api_endpoint=sfn.TaskInput.from_text("path/to/resource"),
+                api_endpoint=sfn.TaskInput.from_text(sfn.JsonPath.format("resource/{}/details", sfn.JsonPath.string_at("$.resourceId"))),
                 body=sfn.TaskInput.from_object({"foo": "bar"}),
                 connection=connection,
                 headers=sfn.TaskInput.from_object({"Content-Type": "application/json"}),
@@ -61902,13 +63560,13 @@ class HttpMethods(enum.Enum):
     Example::
 
         import aws_cdk.aws_eks as eks
-        from aws_cdk.lambda_layer_kubectl_v32 import KubectlV32Layer
+        from aws_cdk.lambda_layer_kubectl_v34 import KubectlV34Layer
         
         
         my_eks_cluster = eks.Cluster(self, "my sample cluster",
-            version=eks.KubernetesVersion.V1_32,
+            version=eks.KubernetesVersion.V1_34,
             cluster_name="myEksCluster",
-            kubectl_layer=KubectlV32Layer(self, "kubectl")
+            kubectl_layer=KubectlV34Layer(self, "kubectl")
         )
         
         tasks.EksCall(self, "Call a EKS Endpoint",
@@ -61932,6 +63590,62 @@ class HttpMethods(enum.Enum):
     '''Retrieve data from a server at the specified resource without the response body.'''
 
 
+@jsii.interface(
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.IBedrockCreateModelCustomizationJobVpcConfig"
+)
+class IBedrockCreateModelCustomizationJobVpcConfig(typing_extensions.Protocol):
+    '''VPC configuration.'''
+
+    @builtins.property
+    @jsii.member(jsii_name="securityGroups")
+    def security_groups(self) -> typing.List[_ISecurityGroup_acf8a799]:
+        '''VPC configuration security groups.
+
+        The minimum number of security groups is 1.
+        The maximum number of security groups is 5.
+        '''
+        ...
+
+    @builtins.property
+    @jsii.member(jsii_name="subnets")
+    def subnets(self) -> typing.List[_ISubnet_d57d1229]:
+        '''VPC configuration subnets.
+
+        The minimum number of subnets is 1.
+        The maximum number of subnets is 16.
+        '''
+        ...
+
+
+class _IBedrockCreateModelCustomizationJobVpcConfigProxy:
+    '''VPC configuration.'''
+
+    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_stepfunctions_tasks.IBedrockCreateModelCustomizationJobVpcConfig"
+
+    @builtins.property
+    @jsii.member(jsii_name="securityGroups")
+    def security_groups(self) -> typing.List[_ISecurityGroup_acf8a799]:
+        '''VPC configuration security groups.
+
+        The minimum number of security groups is 1.
+        The maximum number of security groups is 5.
+        '''
+        return typing.cast(typing.List[_ISecurityGroup_acf8a799], jsii.get(self, "securityGroups"))
+
+    @builtins.property
+    @jsii.member(jsii_name="subnets")
+    def subnets(self) -> typing.List[_ISubnet_d57d1229]:
+        '''VPC configuration subnets.
+
+        The minimum number of subnets is 1.
+        The maximum number of subnets is 16.
+        '''
+        return typing.cast(typing.List[_ISubnet_d57d1229], jsii.get(self, "subnets"))
+
+# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
+typing.cast(typing.Any, IBedrockCreateModelCustomizationJobVpcConfig).__jsii_proxy_class__ = lambda : _IBedrockCreateModelCustomizationJobVpcConfigProxy
+
+
 @jsii.interface(jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.IContainerDefinition")
 class IContainerDefinition(typing_extensions.Protocol):
     '''Configuration of the container used to host the model.
@@ -65695,6 +67409,109 @@ class Monitoring:
         )
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.OutputBucketConfiguration",
+    jsii_struct_bases=[DataBucketConfiguration],
+    name_mapping={"bucket": "bucket", "path": "path"},
+)
+class OutputBucketConfiguration(DataBucketConfiguration):
+    def __init__(
+        self,
+        *,
+        bucket: _IBucket_42e086fd,
+        path: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''S3 bucket configuration for the output data.
+
+        :param bucket: The S3 bucket.
+        :param path: Path to file or directory within the bucket. Default: - root of the bucket
+
+        :exampleMetadata: infused
+
+        Example::
+
+            import aws_cdk.aws_bedrock as bedrock
+            import aws_cdk.aws_kms as kms
+            
+            # output_bucket: s3.IBucket
+            # training_bucket: s3.IBucket
+            # validation_bucket: s3.IBucket
+            # kms_key: kms.IKey
+            # vpc: ec2.IVpc
+            
+            
+            model = bedrock.FoundationModel.from_foundation_model_id(self, "Model", bedrock.FoundationModelIdentifier.AMAZON_TITAN_TEXT_G1_EXPRESS_V1)
+            
+            task = tasks.BedrockCreateModelCustomizationJob(self, "CreateModelCustomizationJob",
+                base_model=model,
+                client_request_token="MyToken",
+                customization_type=tasks.CustomizationType.FINE_TUNING,
+                custom_model_kms_key=kms_key,
+                custom_model_name="MyCustomModel",  # required
+                custom_model_tags=[tasks.CustomModelTag(key="key1", value="value1")],
+                hyper_parameters={
+                    "batch_size": "10"
+                },
+                job_name="MyCustomizationJob",  # required
+                job_tags=[tasks.CustomModelTag(key="key2", value="value2")],
+                output_data=tasks.OutputBucketConfiguration(
+                    bucket=output_bucket,  # required
+                    path="output-data/"
+                ),
+                training_data=tasks.TrainingBucketConfiguration(
+                    bucket=training_bucket,
+                    path="training-data/data.json"
+                ),  # required
+                # If you don't provide validation data, you have to specify `Evaluation percentage` hyperparameter.
+                validation_data=[tasks.ValidationBucketConfiguration(
+                    bucket=validation_bucket,
+                    path="validation-data/data.json"
+                )
+                ],
+                vpc_config={
+                    "security_groups": [ec2.SecurityGroup(self, "SecurityGroup", vpc=vpc)],
+                    "subnets": vpc.private_subnets
+                }
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__05ead3f1760bde00adef48e083438b80e2b20f50fe9ae0d35189d6761a24370f)
+            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
+            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "bucket": bucket,
+        }
+        if path is not None:
+            self._values["path"] = path
+
+    @builtins.property
+    def bucket(self) -> _IBucket_42e086fd:
+        '''The S3 bucket.'''
+        result = self._values.get("bucket")
+        assert result is not None, "Required property 'bucket' is missing"
+        return typing.cast(_IBucket_42e086fd, result)
+
+    @builtins.property
+    def path(self) -> typing.Optional[builtins.str]:
+        '''Path to file or directory within the bucket.
+
+        :default: - root of the bucket
+        '''
+        result = self._values.get("path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "OutputBucketConfiguration(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.OutputDataConfig",
     jsii_struct_bases=[],
@@ -67097,7 +68914,7 @@ class SageMakerCreateEndpointConfig(
         *,
         endpoint_config_name: builtins.str,
         production_variants: typing.Sequence[typing.Union[ProductionVariant, typing.Dict[builtins.str, typing.Any]]],
-        kms_key: typing.Optional[_IKey_5f11635f] = None,
+        kms_key: typing.Optional[_IKeyRef_d4fc6ef3] = None,
         tags: typing.Optional[_TaskInput_91b91b91] = None,
         result_path: typing.Optional[builtins.str] = None,
         result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
@@ -67175,7 +68992,7 @@ class SageMakerCreateEndpointConfig(
         *,
         endpoint_config_name: builtins.str,
         production_variants: typing.Sequence[typing.Union[ProductionVariant, typing.Dict[builtins.str, typing.Any]]],
-        kms_key: typing.Optional[_IKey_5f11635f] = None,
+        kms_key: typing.Optional[_IKeyRef_d4fc6ef3] = None,
         tags: typing.Optional[_TaskInput_91b91b91] = None,
         comment: typing.Optional[builtins.str] = None,
         query_language: typing.Optional[_QueryLanguage_be8414a8] = None,
@@ -67244,7 +69061,7 @@ class SageMakerCreateEndpointConfig(
         *,
         endpoint_config_name: builtins.str,
         production_variants: typing.Sequence[typing.Union[ProductionVariant, typing.Dict[builtins.str, typing.Any]]],
-        kms_key: typing.Optional[_IKey_5f11635f] = None,
+        kms_key: typing.Optional[_IKeyRef_d4fc6ef3] = None,
         tags: typing.Optional[_TaskInput_91b91b91] = None,
         result_path: typing.Optional[builtins.str] = None,
         result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
@@ -67313,6 +69130,12 @@ class SageMakerCreateEndpointConfig(
 
         return typing.cast("SageMakerCreateEndpointConfig", jsii.sinvoke(cls, "jsonPath", [scope, id, props]))
 
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="PROPERTY_INJECTION_ID")
+    def PROPERTY_INJECTION_ID(cls) -> builtins.str:
+        '''Uniquely identifies this class.'''
+        return typing.cast(builtins.str, jsii.sget(cls, "PROPERTY_INJECTION_ID"))
+
     @builtins.property
     @jsii.member(jsii_name="taskMetrics")
     def _task_metrics(self) -> typing.Optional[_TaskMetricsConfig_32ea9403]:
@@ -67368,7 +69191,7 @@ class SageMakerCreateEndpointConfigJsonPathProps(_TaskStateJsonPathBaseProps_57d
         result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
         endpoint_config_name: builtins.str,
         production_variants: typing.Sequence[typing.Union[ProductionVariant, typing.Dict[builtins.str, typing.Any]]],
-        kms_key: typing.Optional[_IKey_5f11635f] = None,
+        kms_key: typing.Optional[_IKeyRef_d4fc6ef3] = None,
         tags: typing.Optional[_TaskInput_91b91b91] = None,
     ) -> None:
         '''Properties for creating an Amazon SageMaker endpoint configuration using JSONPath.
@@ -67401,14 +69224,14 @@ class SageMakerCreateEndpointConfigJsonPathProps(_TaskStateJsonPathBaseProps_57d
             # The values are placeholders you should change.
             import aws_cdk as cdk
             from aws_cdk import aws_ec2 as ec2
-            from aws_cdk import aws_kms as kms
             from aws_cdk import aws_stepfunctions as stepfunctions
             from aws_cdk import aws_stepfunctions_tasks as stepfunctions_tasks
+            from aws_cdk.interfaces import aws_kms as interfaces_aws_kms
             
             # accelerator_type: stepfunctions_tasks.AcceleratorType
             # assign: Any
             # instance_type: ec2.InstanceType
-            # key: kms.Key
+            # key_ref: interfaces_aws_kms.IKeyRef
             # result_selector: Any
             # task_input: stepfunctions.TaskInput
             # task_role: stepfunctions.TaskRole
@@ -67439,7 +69262,7 @@ class SageMakerCreateEndpointConfigJsonPathProps(_TaskStateJsonPathBaseProps_57d
                 heartbeat_timeout=timeout,
                 input_path="inputPath",
                 integration_pattern=stepfunctions.IntegrationPattern.REQUEST_RESPONSE,
-                kms_key=key,
+                kms_key=key_ref,
                 output_path="outputPath",
                 query_language=stepfunctions.QueryLanguage.JSON_PATH,
                 result_path="resultPath",
@@ -67707,13 +69530,13 @@ class SageMakerCreateEndpointConfigJsonPathProps(_TaskStateJsonPathBaseProps_57d
         return typing.cast(typing.List[ProductionVariant], result)
 
     @builtins.property
-    def kms_key(self) -> typing.Optional[_IKey_5f11635f]:
+    def kms_key(self) -> typing.Optional[_IKeyRef_d4fc6ef3]:
         '''AWS Key Management Service key that Amazon SageMaker uses to encrypt data on the storage volume attached to the ML compute instance that hosts the endpoint.
 
         :default: - None
         '''
         result = self._values.get("kms_key")
-        return typing.cast(typing.Optional[_IKey_5f11635f], result)
+        return typing.cast(typing.Optional[_IKeyRef_d4fc6ef3], result)
 
     @builtins.property
     def tags(self) -> typing.Optional[_TaskInput_91b91b91]:
@@ -67774,7 +69597,7 @@ class SageMakerCreateEndpointConfigJsonataProps(_TaskStateJsonataBaseProps_0e917
         outputs: typing.Any = None,
         endpoint_config_name: builtins.str,
         production_variants: typing.Sequence[typing.Union[ProductionVariant, typing.Dict[builtins.str, typing.Any]]],
-        kms_key: typing.Optional[_IKey_5f11635f] = None,
+        kms_key: typing.Optional[_IKeyRef_d4fc6ef3] = None,
         tags: typing.Optional[_TaskInput_91b91b91] = None,
     ) -> None:
         '''Properties for creating an Amazon SageMaker endpoint configuration using JSONata.
@@ -67804,14 +69627,14 @@ class SageMakerCreateEndpointConfigJsonataProps(_TaskStateJsonataBaseProps_0e917
             # The values are placeholders you should change.
             import aws_cdk as cdk
             from aws_cdk import aws_ec2 as ec2
-            from aws_cdk import aws_kms as kms
             from aws_cdk import aws_stepfunctions as stepfunctions
             from aws_cdk import aws_stepfunctions_tasks as stepfunctions_tasks
+            from aws_cdk.interfaces import aws_kms as interfaces_aws_kms
             
             # accelerator_type: stepfunctions_tasks.AcceleratorType
             # assign: Any
             # instance_type: ec2.InstanceType
-            # key: kms.Key
+            # key_ref: interfaces_aws_kms.IKeyRef
             # outputs: Any
             # task_input: stepfunctions.TaskInput
             # task_role: stepfunctions.TaskRole
@@ -67841,7 +69664,7 @@ class SageMakerCreateEndpointConfigJsonataProps(_TaskStateJsonataBaseProps_0e917
                 heartbeat=cdk.Duration.minutes(30),
                 heartbeat_timeout=timeout,
                 integration_pattern=stepfunctions.IntegrationPattern.REQUEST_RESPONSE,
-                kms_key=key,
+                kms_key=key_ref,
                 outputs=outputs,
                 query_language=stepfunctions.QueryLanguage.JSON_PATH,
                 state_name="stateName",
@@ -68061,13 +69884,13 @@ class SageMakerCreateEndpointConfigJsonataProps(_TaskStateJsonataBaseProps_0e917
         return typing.cast(typing.List[ProductionVariant], result)
 
     @builtins.property
-    def kms_key(self) -> typing.Optional[_IKey_5f11635f]:
+    def kms_key(self) -> typing.Optional[_IKeyRef_d4fc6ef3]:
         '''AWS Key Management Service key that Amazon SageMaker uses to encrypt data on the storage volume attached to the ML compute instance that hosts the endpoint.
 
         :default: - None
         '''
         result = self._values.get("kms_key")
-        return typing.cast(typing.Optional[_IKey_5f11635f], result)
+        return typing.cast(typing.Optional[_IKeyRef_d4fc6ef3], result)
 
     @builtins.property
     def tags(self) -> typing.Optional[_TaskInput_91b91b91]:
@@ -68136,7 +69959,7 @@ class SageMakerCreateEndpointConfigProps(_TaskStateBaseProps_3a62b6d0):
         result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
         endpoint_config_name: builtins.str,
         production_variants: typing.Sequence[typing.Union[ProductionVariant, typing.Dict[builtins.str, typing.Any]]],
-        kms_key: typing.Optional[_IKey_5f11635f] = None,
+        kms_key: typing.Optional[_IKeyRef_d4fc6ef3] = None,
         tags: typing.Optional[_TaskInput_91b91b91] = None,
     ) -> None:
         '''Properties for creating an Amazon SageMaker endpoint configuration.
@@ -68451,13 +70274,13 @@ class SageMakerCreateEndpointConfigProps(_TaskStateBaseProps_3a62b6d0):
         return typing.cast(typing.List[ProductionVariant], result)
 
     @builtins.property
-    def kms_key(self) -> typing.Optional[_IKey_5f11635f]:
+    def kms_key(self) -> typing.Optional[_IKeyRef_d4fc6ef3]:
         '''AWS Key Management Service key that Amazon SageMaker uses to encrypt data on the storage volume attached to the ML compute instance that hosts the endpoint.
 
         :default: - None
         '''
         result = self._values.get("kms_key")
-        return typing.cast(typing.Optional[_IKey_5f11635f], result)
+        return typing.cast(typing.Optional[_IKeyRef_d4fc6ef3], result)
 
     @builtins.property
     def tags(self) -> typing.Optional[_TaskInput_91b91b91]:
@@ -69846,6 +71669,12 @@ class SageMakerCreateModel(
             check_type(argname="argument security_group", value=security_group, expected_type=type_hints["security_group"])
         return typing.cast(None, jsii.invoke(self, "addSecurityGroup", [security_group]))
 
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="PROPERTY_INJECTION_ID")
+    def PROPERTY_INJECTION_ID(cls) -> builtins.str:
+        '''Uniquely identifies this class.'''
+        return typing.cast(builtins.str, jsii.sget(cls, "PROPERTY_INJECTION_ID"))
+
     @builtins.property
     @jsii.member(jsii_name="connections")
     def connections(self) -> _Connections_0f31fce8:
@@ -71561,6 +73390,12 @@ class SageMakerCreateTrainingJob(
             check_type(argname="argument security_group", value=security_group, expected_type=type_hints["security_group"])
         return typing.cast(None, jsii.invoke(self, "addSecurityGroup", [security_group]))
 
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="PROPERTY_INJECTION_ID")
+    def PROPERTY_INJECTION_ID(cls) -> builtins.str:
+        '''Uniquely identifies this class.'''
+        return typing.cast(builtins.str, jsii.sget(cls, "PROPERTY_INJECTION_ID"))
+
     @builtins.property
     @jsii.member(jsii_name="connections")
     def connections(self) -> _Connections_0f31fce8:
@@ -73763,13 +75598,13 @@ class SageMakerCreateTransformJobJsonPathProps(_TaskStateJsonPathBaseProps_57dc2
             import aws_cdk as cdk
             from aws_cdk import aws_ec2 as ec2
             from aws_cdk import aws_iam as iam
-            from aws_cdk import aws_kms as kms
             from aws_cdk import aws_stepfunctions as stepfunctions
             from aws_cdk import aws_stepfunctions_tasks as stepfunctions_tasks
+            from aws_cdk.interfaces import aws_kms as interfaces_aws_kms
             
             # assign: Any
             # instance_type: ec2.InstanceType
-            # key: kms.Key
+            # key_ref: interfaces_aws_kms.IKeyRef
             # result_selector: Any
             # role: iam.Role
             # size: cdk.Size
@@ -73800,7 +75635,7 @@ class SageMakerCreateTransformJobJsonPathProps(_TaskStateJsonPathBaseProps_57dc2
                     # the properties below are optional
                     accept="accept",
                     assemble_with=stepfunctions_tasks.AssembleWith.NONE,
-                    encryption_key=key
+                    encryption_key=key_ref
                 ),
             
                 # the properties below are optional
@@ -73843,7 +75678,7 @@ class SageMakerCreateTransformJobJsonPathProps(_TaskStateJsonPathBaseProps_57dc2
                     instance_type=instance_type,
             
                     # the properties below are optional
-                    volume_encryption_key=key
+                    volume_encryption_key=key_ref
                 )
             )
         '''
@@ -74322,13 +76157,13 @@ class SageMakerCreateTransformJobJsonataProps(_TaskStateJsonataBaseProps_0e91775
             import aws_cdk as cdk
             from aws_cdk import aws_ec2 as ec2
             from aws_cdk import aws_iam as iam
-            from aws_cdk import aws_kms as kms
             from aws_cdk import aws_stepfunctions as stepfunctions
             from aws_cdk import aws_stepfunctions_tasks as stepfunctions_tasks
+            from aws_cdk.interfaces import aws_kms as interfaces_aws_kms
             
             # assign: Any
             # instance_type: ec2.InstanceType
-            # key: kms.Key
+            # key_ref: interfaces_aws_kms.IKeyRef
             # outputs: Any
             # role: iam.Role
             # size: cdk.Size
@@ -74359,7 +76194,7 @@ class SageMakerCreateTransformJobJsonataProps(_TaskStateJsonataBaseProps_0e91775
                     # the properties below are optional
                     accept="accept",
                     assemble_with=stepfunctions_tasks.AssembleWith.NONE,
-                    encryption_key=key
+                    encryption_key=key_ref
                 ),
             
                 # the properties below are optional
@@ -74397,7 +76232,7 @@ class SageMakerCreateTransformJobJsonataProps(_TaskStateJsonataBaseProps_0e91775
                     instance_type=instance_type,
             
                     # the properties below are optional
-                    volume_encryption_key=key
+                    volume_encryption_key=key_ref
                 )
             )
         '''
@@ -82849,6 +84684,109 @@ class TaskEnvironmentVariable:
         )
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.TrainingBucketConfiguration",
+    jsii_struct_bases=[DataBucketConfiguration],
+    name_mapping={"bucket": "bucket", "path": "path"},
+)
+class TrainingBucketConfiguration(DataBucketConfiguration):
+    def __init__(
+        self,
+        *,
+        bucket: _IBucket_42e086fd,
+        path: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''S3 bucket configuration for the training data.
+
+        :param bucket: The S3 bucket.
+        :param path: Path to file or directory within the bucket. Default: - root of the bucket
+
+        :exampleMetadata: infused
+
+        Example::
+
+            import aws_cdk.aws_bedrock as bedrock
+            import aws_cdk.aws_kms as kms
+            
+            # output_bucket: s3.IBucket
+            # training_bucket: s3.IBucket
+            # validation_bucket: s3.IBucket
+            # kms_key: kms.IKey
+            # vpc: ec2.IVpc
+            
+            
+            model = bedrock.FoundationModel.from_foundation_model_id(self, "Model", bedrock.FoundationModelIdentifier.AMAZON_TITAN_TEXT_G1_EXPRESS_V1)
+            
+            task = tasks.BedrockCreateModelCustomizationJob(self, "CreateModelCustomizationJob",
+                base_model=model,
+                client_request_token="MyToken",
+                customization_type=tasks.CustomizationType.FINE_TUNING,
+                custom_model_kms_key=kms_key,
+                custom_model_name="MyCustomModel",  # required
+                custom_model_tags=[tasks.CustomModelTag(key="key1", value="value1")],
+                hyper_parameters={
+                    "batch_size": "10"
+                },
+                job_name="MyCustomizationJob",  # required
+                job_tags=[tasks.CustomModelTag(key="key2", value="value2")],
+                output_data=tasks.OutputBucketConfiguration(
+                    bucket=output_bucket,  # required
+                    path="output-data/"
+                ),
+                training_data=tasks.TrainingBucketConfiguration(
+                    bucket=training_bucket,
+                    path="training-data/data.json"
+                ),  # required
+                # If you don't provide validation data, you have to specify `Evaluation percentage` hyperparameter.
+                validation_data=[tasks.ValidationBucketConfiguration(
+                    bucket=validation_bucket,
+                    path="validation-data/data.json"
+                )
+                ],
+                vpc_config={
+                    "security_groups": [ec2.SecurityGroup(self, "SecurityGroup", vpc=vpc)],
+                    "subnets": vpc.private_subnets
+                }
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__682a3d293d520e48cda4b322d7a11a901469838caf114187b949c74301eba9a0)
+            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
+            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "bucket": bucket,
+        }
+        if path is not None:
+            self._values["path"] = path
+
+    @builtins.property
+    def bucket(self) -> _IBucket_42e086fd:
+        '''The S3 bucket.'''
+        result = self._values.get("bucket")
+        assert result is not None, "Required property 'bucket' is missing"
+        return typing.cast(_IBucket_42e086fd, result)
+
+    @builtins.property
+    def path(self) -> typing.Optional[builtins.str]:
+        '''Path to file or directory within the bucket.
+
+        :default: - root of the bucket
+        '''
+        result = self._values.get("path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "TrainingBucketConfiguration(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.TransformDataSource",
     jsii_struct_bases=[],
@@ -83055,7 +84993,7 @@ class TransformOutput:
         s3_output_path: builtins.str,
         accept: typing.Optional[builtins.str] = None,
         assemble_with: typing.Optional[AssembleWith] = None,
-        encryption_key: typing.Optional[_IKey_5f11635f] = None,
+        encryption_key: typing.Optional[_IKeyRef_d4fc6ef3] = None,
     ) -> None:
         '''S3 location where you want Amazon SageMaker to save the results from the transform job.
 
@@ -83134,13 +85072,13 @@ class TransformOutput:
         return typing.cast(typing.Optional[AssembleWith], result)
 
     @builtins.property
-    def encryption_key(self) -> typing.Optional[_IKey_5f11635f]:
+    def encryption_key(self) -> typing.Optional[_IKeyRef_d4fc6ef3]:
         '''AWS KMS key that Amazon SageMaker uses to encrypt the model artifacts at rest using Amazon S3 server-side encryption.
 
         :default: - default KMS key for Amazon S3 for your role's account.
         '''
         result = self._values.get("encryption_key")
-        return typing.cast(typing.Optional[_IKey_5f11635f], result)
+        return typing.cast(typing.Optional[_IKeyRef_d4fc6ef3], result)
 
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
@@ -83169,7 +85107,7 @@ class TransformResources:
         *,
         instance_count: jsii.Number,
         instance_type: _InstanceType_f64915b9,
-        volume_encryption_key: typing.Optional[_IKey_5f11635f] = None,
+        volume_encryption_key: typing.Optional[_IKeyRef_d4fc6ef3] = None,
     ) -> None:
         '''ML compute instances for the transform job.
 
@@ -83232,13 +85170,13 @@ class TransformResources:
         return typing.cast(_InstanceType_f64915b9, result)
 
     @builtins.property
-    def volume_encryption_key(self) -> typing.Optional[_IKey_5f11635f]:
+    def volume_encryption_key(self) -> typing.Optional[_IKeyRef_d4fc6ef3]:
         '''AWS KMS key that Amazon SageMaker uses to encrypt data on the storage volume attached to the ML compute instance(s).
 
         :default: - None
         '''
         result = self._values.get("volume_encryption_key")
-        return typing.cast(typing.Optional[_IKey_5f11635f], result)
+        return typing.cast(typing.Optional[_IKeyRef_d4fc6ef3], result)
 
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
@@ -83352,7 +85290,7 @@ class URLEncodingFormat(enum.Enum):
         
         tasks.HttpInvoke(self, "Invoke HTTP API",
             api_root="https://api.example.com",
-            api_endpoint=sfn.TaskInput.from_text("path/to/resource"),
+            api_endpoint=sfn.TaskInput.from_text(sfn.JsonPath.format("resource/{}/details", sfn.JsonPath.string_at("$.resourceId"))),
             body=sfn.TaskInput.from_object({"foo": "bar"}),
             connection=connection,
             headers=sfn.TaskInput.from_object({"Content-Type": "application/json"}),
@@ -83388,6 +85326,79 @@ class URLEncodingFormat(enum.Enum):
     '''
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.ValidationBucketConfiguration",
+    jsii_struct_bases=[DataBucketConfiguration],
+    name_mapping={"bucket": "bucket", "path": "path"},
+)
+class ValidationBucketConfiguration(DataBucketConfiguration):
+    def __init__(
+        self,
+        *,
+        bucket: _IBucket_42e086fd,
+        path: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''S3 bucket configuration for the validation data.
+
+        :param bucket: The S3 bucket.
+        :param path: Path to file or directory within the bucket. Default: - root of the bucket
+
+        :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_s3 as s3
+            from aws_cdk import aws_stepfunctions_tasks as stepfunctions_tasks
+            
+            # bucket: s3.Bucket
+            
+            validation_bucket_configuration = stepfunctions_tasks.ValidationBucketConfiguration(
+                bucket=bucket,
+            
+                # the properties below are optional
+                path="path"
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__a6205038f5bd369810feab5dd42ebc706a68c088fceea69b083c4878117ca890)
+            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
+            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "bucket": bucket,
+        }
+        if path is not None:
+            self._values["path"] = path
+
+    @builtins.property
+    def bucket(self) -> _IBucket_42e086fd:
+        '''The S3 bucket.'''
+        result = self._values.get("bucket")
+        assert result is not None, "Required property 'bucket' is missing"
+        return typing.cast(_IBucket_42e086fd, result)
+
+    @builtins.property
+    def path(self) -> typing.Optional[builtins.str]:
+        '''Path to file or directory within the bucket.
+
+        :default: - root of the bucket
+        '''
+        result = self._values.get("path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "ValidationBucketConfiguration(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 class VirtualClusterInput(
     metaclass=jsii.JSIIMeta,
     jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.VirtualClusterInput",
@@ -85640,25 +87651,25 @@ class EcsEc2LaunchTarget(
     @jsii.member(jsii_name="bind")
     def bind(
         self,
-        _task: EcsRunTask,
+        task: EcsRunTask,
         *,
         task_definition: _ITaskDefinition_889ba4d8,
         cluster: typing.Optional[_ICluster_16cddd09] = None,
     ) -> EcsLaunchTargetConfig:
         '''Called when the EC2 launch type is configured on RunTask.
 
-        :param _task: -
+        :param task: -
         :param task_definition: Task definition to run Docker containers in Amazon ECS.
         :param cluster: A regional grouping of one or more container instances on which you can run tasks and services. Default: - No cluster
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__193210761ae10b68dfdc04ae454b8c432675bc12145b65077c7c23ee6f35daa2)
-            check_type(argname="argument _task", value=_task, expected_type=type_hints["_task"])
+            check_type(argname="argument task", value=task, expected_type=type_hints["task"])
         launch_target_options = LaunchTargetBindOptions(
             task_definition=task_definition, cluster=cluster
         )
 
-        return typing.cast(EcsLaunchTargetConfig, jsii.invoke(self, "bind", [_task, launch_target_options]))
+        return typing.cast(EcsLaunchTargetConfig, jsii.invoke(self, "bind", [task, launch_target_options]))
 
 
 @jsii.implements(IEcsLaunchTarget)
@@ -85715,25 +87726,25 @@ class EcsFargateLaunchTarget(
     @jsii.member(jsii_name="bind")
     def bind(
         self,
-        _task: EcsRunTask,
+        task: EcsRunTask,
         *,
         task_definition: _ITaskDefinition_889ba4d8,
         cluster: typing.Optional[_ICluster_16cddd09] = None,
     ) -> EcsLaunchTargetConfig:
         '''Called when the Fargate launch type configured on RunTask.
 
-        :param _task: -
+        :param task: -
         :param task_definition: Task definition to run Docker containers in Amazon ECS.
         :param cluster: A regional grouping of one or more container instances on which you can run tasks and services. Default: - No cluster
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__7c19025da4101b4b8d2482e0216270cc5e94fe58381fdba0b4cf99f04e2776b9)
-            check_type(argname="argument _task", value=_task, expected_type=type_hints["_task"])
+            check_type(argname="argument task", value=task, expected_type=type_hints["task"])
         launch_target_options = LaunchTargetBindOptions(
             task_definition=task_definition, cluster=cluster
         )
 
-        return typing.cast(EcsLaunchTargetConfig, jsii.invoke(self, "bind", [_task, launch_target_options]))
+        return typing.cast(EcsLaunchTargetConfig, jsii.invoke(self, "bind", [task, launch_target_options]))
 
 
 __all__ = [
@@ -85768,6 +87779,8 @@ __all__ = [
     "BatchSubmitJobJsonPathProps",
     "BatchSubmitJobJsonataProps",
     "BatchSubmitJobProps",
+    "BedrockCreateModelCustomizationJob",
+    "BedrockCreateModelCustomizationJobProps",
     "BedrockInvokeModel",
     "BedrockInvokeModelInputProps",
     "BedrockInvokeModelJsonPathProps",
@@ -85814,6 +87827,9 @@ __all__ = [
     "ContainerOverride",
     "ContainerOverrides",
     "CronOptions",
+    "CustomModelTag",
+    "CustomizationType",
+    "DataBucketConfiguration",
     "DataSource",
     "DockerImage",
     "DockerImageConfig",
@@ -85927,6 +87943,7 @@ __all__ = [
     "HttpInvokeProps",
     "HttpMethod",
     "HttpMethods",
+    "IBedrockCreateModelCustomizationJobVpcConfig",
     "IContainerDefinition",
     "IEcsLaunchTarget",
     "ISageMakerTask",
@@ -85949,6 +87966,7 @@ __all__ = [
     "Mode",
     "ModelClientOptions",
     "Monitoring",
+    "OutputBucketConfiguration",
     "OutputDataConfig",
     "ProductionVariant",
     "QueryExecutionContext",
@@ -86009,12 +88027,14 @@ __all__ = [
     "StepFunctionsStartExecutionProps",
     "StoppingCondition",
     "TaskEnvironmentVariable",
+    "TrainingBucketConfiguration",
     "TransformDataSource",
     "TransformInput",
     "TransformOutput",
     "TransformResources",
     "TransformS3DataSource",
     "URLEncodingFormat",
+    "ValidationBucketConfiguration",
     "VirtualClusterInput",
     "VpcConfig",
     "WorkerConfigurationProperty",
@@ -86818,6 +88838,78 @@ def _typecheckingstub__c3197d21dad4ba55e29e09cf770b47b7859167ae6b1ae5ef674cca1be
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__05f50c48ead9c1041aeef184ab271f7236e2832bc9e7175e9c6909f2fc4097e0(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    base_model: _IModel_b88b328a,
+    custom_model_name: builtins.str,
+    job_name: builtins.str,
+    output_data: typing.Union[OutputBucketConfiguration, typing.Dict[builtins.str, typing.Any]],
+    training_data: typing.Union[TrainingBucketConfiguration, typing.Dict[builtins.str, typing.Any]],
+    client_request_token: typing.Optional[builtins.str] = None,
+    customization_type: typing.Optional[CustomizationType] = None,
+    custom_model_kms_key: typing.Optional[_IKey_5f11635f] = None,
+    custom_model_tags: typing.Optional[typing.Sequence[typing.Union[CustomModelTag, typing.Dict[builtins.str, typing.Any]]]] = None,
+    hyper_parameters: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    job_tags: typing.Optional[typing.Sequence[typing.Union[CustomModelTag, typing.Dict[builtins.str, typing.Any]]]] = None,
+    role: typing.Optional[_IRoleRef_8400221f] = None,
+    validation_data: typing.Optional[typing.Sequence[typing.Union[ValidationBucketConfiguration, typing.Dict[builtins.str, typing.Any]]]] = None,
+    vpc_config: typing.Optional[IBedrockCreateModelCustomizationJobVpcConfig] = None,
+    result_path: typing.Optional[builtins.str] = None,
+    result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+    comment: typing.Optional[builtins.str] = None,
+    query_language: typing.Optional[_QueryLanguage_be8414a8] = None,
+    state_name: 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,
+    integration_pattern: typing.Optional[_IntegrationPattern_949291bc] = None,
+    task_timeout: typing.Optional[_Timeout_d7c10551] = None,
+    timeout: typing.Optional[_Duration_4839e8c3] = None,
+    assign: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+    input_path: typing.Optional[builtins.str] = None,
+    output_path: typing.Optional[builtins.str] = None,
+    outputs: typing.Any = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__4a1348489dd866713bad4f53a20bf5de0eff5edebddfb3011e85cf03da5f68d2(
+    *,
+    comment: typing.Optional[builtins.str] = None,
+    query_language: typing.Optional[_QueryLanguage_be8414a8] = None,
+    state_name: 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,
+    integration_pattern: typing.Optional[_IntegrationPattern_949291bc] = None,
+    task_timeout: typing.Optional[_Timeout_d7c10551] = None,
+    timeout: typing.Optional[_Duration_4839e8c3] = None,
+    assign: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+    input_path: typing.Optional[builtins.str] = None,
+    output_path: typing.Optional[builtins.str] = None,
+    outputs: typing.Any = None,
+    result_path: typing.Optional[builtins.str] = None,
+    result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+    base_model: _IModel_b88b328a,
+    custom_model_name: builtins.str,
+    job_name: builtins.str,
+    output_data: typing.Union[OutputBucketConfiguration, typing.Dict[builtins.str, typing.Any]],
+    training_data: typing.Union[TrainingBucketConfiguration, typing.Dict[builtins.str, typing.Any]],
+    client_request_token: typing.Optional[builtins.str] = None,
+    customization_type: typing.Optional[CustomizationType] = None,
+    custom_model_kms_key: typing.Optional[_IKey_5f11635f] = None,
+    custom_model_tags: typing.Optional[typing.Sequence[typing.Union[CustomModelTag, typing.Dict[builtins.str, typing.Any]]]] = None,
+    hyper_parameters: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    job_tags: typing.Optional[typing.Sequence[typing.Union[CustomModelTag, typing.Dict[builtins.str, typing.Any]]]] = None,
+    role: typing.Optional[_IRoleRef_8400221f] = None,
+    validation_data: typing.Optional[typing.Sequence[typing.Union[ValidationBucketConfiguration, typing.Dict[builtins.str, typing.Any]]]] = None,
+    vpc_config: typing.Optional[IBedrockCreateModelCustomizationJobVpcConfig] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__3b20c515efa874adacf78d373dbda10fc59e519a3bd1b280ecbf56409aea2544(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
@@ -88038,6 +90130,22 @@ def _typecheckingstub__3ded07e1f80001916cedf33047f0de79b459fade9caa718d154ce1255
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__83c62fca1c3250b9c5ee6e19dd3dfc1c4accd6cbf494208ce8b177e8b37ab802(
+    *,
+    key: builtins.str,
+    value: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__a310fa6911b62dab87f8ad67600f727aa7262c59f0ca09c7df5e3e7af25a63ee(
+    *,
+    bucket: _IBucket_42e086fd,
+    path: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__ae608c3d9d2fb12a77379a82dd6b04cdafe048a3cd431a1c95d472c19c1cbcd4(
     *,
     s3_data_source: typing.Union[S3DataSource, typing.Dict[builtins.str, typing.Any]],
@@ -90041,9 +92149,12 @@ def _typecheckingstub__cea19fa2105afe952446f5bd0f605c16f7727beccef02df2d7846fc03
     cluster_role: typing.Optional[_IRole_235f5d8e] = None,
     configurations: typing.Optional[typing.Sequence[typing.Union[EmrCreateCluster.ConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     custom_ami_id: typing.Optional[builtins.str] = None,
+    ebs_root_volume_iops: typing.Optional[jsii.Number] = None,
     ebs_root_volume_size: typing.Optional[_Size_7b441c34] = None,
+    ebs_root_volume_throughput: typing.Optional[jsii.Number] = None,
     kerberos_attributes: typing.Optional[typing.Union[EmrCreateCluster.KerberosAttributesProperty, typing.Dict[builtins.str, typing.Any]]] = None,
     log_uri: typing.Optional[builtins.str] = None,
+    managed_scaling_policy: typing.Optional[typing.Union[EmrCreateCluster.ManagedScalingPolicyProperty, typing.Dict[builtins.str, typing.Any]]] = None,
     release_label: typing.Optional[builtins.str] = None,
     scale_down_behavior: typing.Optional[EmrCreateCluster.EmrClusterScaleDownBehavior] = None,
     security_configuration: typing.Optional[builtins.str] = None,
@@ -90084,9 +92195,12 @@ def _typecheckingstub__c919e6f14f726c30d5e9bfdcd68c1528feb537ad74733ba631023ae0e
     cluster_role: typing.Optional[_IRole_235f5d8e] = None,
     configurations: typing.Optional[typing.Sequence[typing.Union[EmrCreateCluster.ConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     custom_ami_id: typing.Optional[builtins.str] = None,
+    ebs_root_volume_iops: typing.Optional[jsii.Number] = None,
     ebs_root_volume_size: typing.Optional[_Size_7b441c34] = None,
+    ebs_root_volume_throughput: typing.Optional[jsii.Number] = None,
     kerberos_attributes: typing.Optional[typing.Union[EmrCreateCluster.KerberosAttributesProperty, typing.Dict[builtins.str, typing.Any]]] = None,
     log_uri: typing.Optional[builtins.str] = None,
+    managed_scaling_policy: typing.Optional[typing.Union[EmrCreateCluster.ManagedScalingPolicyProperty, typing.Dict[builtins.str, typing.Any]]] = None,
     release_label: typing.Optional[builtins.str] = None,
     scale_down_behavior: typing.Optional[EmrCreateCluster.EmrClusterScaleDownBehavior] = None,
     security_configuration: typing.Optional[builtins.str] = None,
@@ -90123,9 +92237,12 @@ def _typecheckingstub__c0ca62f39b0f27c784b5c3bd197f4bcb1898d07af8d6176a5e24d6cb4
     cluster_role: typing.Optional[_IRole_235f5d8e] = None,
     configurations: typing.Optional[typing.Sequence[typing.Union[EmrCreateCluster.ConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     custom_ami_id: typing.Optional[builtins.str] = None,
+    ebs_root_volume_iops: typing.Optional[jsii.Number] = None,
     ebs_root_volume_size: typing.Optional[_Size_7b441c34] = None,
+    ebs_root_volume_throughput: typing.Optional[jsii.Number] = None,
     kerberos_attributes: typing.Optional[typing.Union[EmrCreateCluster.KerberosAttributesProperty, typing.Dict[builtins.str, typing.Any]]] = None,
     log_uri: typing.Optional[builtins.str] = None,
+    managed_scaling_policy: typing.Optional[typing.Union[EmrCreateCluster.ManagedScalingPolicyProperty, typing.Dict[builtins.str, typing.Any]]] = None,
     release_label: typing.Optional[builtins.str] = None,
     scale_down_behavior: typing.Optional[EmrCreateCluster.EmrClusterScaleDownBehavior] = None,
     security_configuration: typing.Optional[builtins.str] = None,
@@ -90297,6 +92414,24 @@ def _typecheckingstub__55fd4ff6bee4f87932c9408a964df71df75a5355df79438f571de69d1
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__456056f16dcf97fd1f56ad4f544f9e6a7740b916af0bb528c7039258390c676c(
+    *,
+    maximum_capacity_units: jsii.Number,
+    minimum_capacity_units: jsii.Number,
+    unit_type: EmrCreateCluster.ComputeLimitsUnitType,
+    maximum_core_capacity_units: typing.Optional[jsii.Number] = None,
+    maximum_on_demand_capacity_units: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__179ad22f7f4bb419f4267ee887aae9d8eb939feb472f44c905e5f5d18bca8899(
+    *,
+    compute_limits: typing.Optional[typing.Union[EmrCreateCluster.ManagedScalingComputeLimitsProperty, typing.Dict[builtins.str, typing.Any]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__b08b745951eed0d937bba525b556337b2cbf7ac04b7cf244aa893e39122e1abc(
     *,
     key: builtins.str,
@@ -90416,9 +92551,12 @@ def _typecheckingstub__8eee079f7d9817361a59216197eaa0f6c6e38fddbd968457fbb263e42
     cluster_role: typing.Optional[_IRole_235f5d8e] = None,
     configurations: typing.Optional[typing.Sequence[typing.Union[EmrCreateCluster.ConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     custom_ami_id: typing.Optional[builtins.str] = None,
+    ebs_root_volume_iops: typing.Optional[jsii.Number] = None,
     ebs_root_volume_size: typing.Optional[_Size_7b441c34] = None,
+    ebs_root_volume_throughput: typing.Optional[jsii.Number] = None,
     kerberos_attributes: typing.Optional[typing.Union[EmrCreateCluster.KerberosAttributesProperty, typing.Dict[builtins.str, typing.Any]]] = None,
     log_uri: typing.Optional[builtins.str] = None,
+    managed_scaling_policy: typing.Optional[typing.Union[EmrCreateCluster.ManagedScalingPolicyProperty, typing.Dict[builtins.str, typing.Any]]] = None,
     release_label: typing.Optional[builtins.str] = None,
     scale_down_behavior: typing.Optional[EmrCreateCluster.EmrClusterScaleDownBehavior] = None,
     security_configuration: typing.Optional[builtins.str] = None,
@@ -90453,9 +92591,12 @@ def _typecheckingstub__e0198d308a9f96d3aadda143c9d8a0ef5848603e760f6a16d02390d98
     cluster_role: typing.Optional[_IRole_235f5d8e] = None,
     configurations: typing.Optional[typing.Sequence[typing.Union[EmrCreateCluster.ConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     custom_ami_id: typing.Optional[builtins.str] = None,
+    ebs_root_volume_iops: typing.Optional[jsii.Number] = None,
     ebs_root_volume_size: typing.Optional[_Size_7b441c34] = None,
+    ebs_root_volume_throughput: typing.Optional[jsii.Number] = None,
     kerberos_attributes: typing.Optional[typing.Union[EmrCreateCluster.KerberosAttributesProperty, typing.Dict[builtins.str, typing.Any]]] = None,
     log_uri: typing.Optional[builtins.str] = None,
+    managed_scaling_policy: typing.Optional[typing.Union[EmrCreateCluster.ManagedScalingPolicyProperty, typing.Dict[builtins.str, typing.Any]]] = None,
     release_label: typing.Optional[builtins.str] = None,
     scale_down_behavior: typing.Optional[EmrCreateCluster.EmrClusterScaleDownBehavior] = None,
     security_configuration: typing.Optional[builtins.str] = None,
@@ -90494,9 +92635,12 @@ def _typecheckingstub__47264d4efff2249070476b1432ca851665096bb89026c6d6564ff3c77
     cluster_role: typing.Optional[_IRole_235f5d8e] = None,
     configurations: typing.Optional[typing.Sequence[typing.Union[EmrCreateCluster.ConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     custom_ami_id: typing.Optional[builtins.str] = None,
+    ebs_root_volume_iops: typing.Optional[jsii.Number] = None,
     ebs_root_volume_size: typing.Optional[_Size_7b441c34] = None,
+    ebs_root_volume_throughput: typing.Optional[jsii.Number] = None,
     kerberos_attributes: typing.Optional[typing.Union[EmrCreateCluster.KerberosAttributesProperty, typing.Dict[builtins.str, typing.Any]]] = None,
     log_uri: typing.Optional[builtins.str] = None,
+    managed_scaling_policy: typing.Optional[typing.Union[EmrCreateCluster.ManagedScalingPolicyProperty, typing.Dict[builtins.str, typing.Any]]] = None,
     release_label: typing.Optional[builtins.str] = None,
     scale_down_behavior: typing.Optional[EmrCreateCluster.EmrClusterScaleDownBehavior] = None,
     security_configuration: typing.Optional[builtins.str] = None,
@@ -91096,6 +93240,7 @@ def _typecheckingstub__7da4306c848323ad0fd19f879d1e450efab7eb83fb1ef1cb0d748933f
     id: builtins.str,
     *,
     expression: builtins.str,
+    architecture: typing.Optional[_Architecture_12d5a53f] = None,
     runtime: typing.Optional[_Runtime_b4eaa844] = None,
     result_path: typing.Optional[builtins.str] = None,
     result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
@@ -91134,6 +93279,7 @@ def _typecheckingstub__7b660a2d739c33e835b358bdf384dcda902727f35dd042f5cd8486b6f
     result_path: typing.Optional[builtins.str] = None,
     result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
     expression: builtins.str,
+    architecture: typing.Optional[_Architecture_12d5a53f] = None,
     runtime: typing.Optional[_Runtime_b4eaa844] = None,
 ) -> None:
     """Type checking stubs"""
@@ -92480,6 +94626,14 @@ def _typecheckingstub__2c0e40b619f7707d6a2a3d70d10b988fa758ad2484283c28988ee8d61
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__05ead3f1760bde00adef48e083438b80e2b20f50fe9ae0d35189d6761a24370f(
+    *,
+    bucket: _IBucket_42e086fd,
+    path: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__eb710544769244822847e500c7742fc5cdede3a3225e828a8b782f786596237b(
     *,
     s3_output_location: S3Location,
@@ -92666,7 +94820,7 @@ def _typecheckingstub__7955865e1edbdbe14b7d0785bfa36c7b48efa077af003aaf9df70da12
     *,
     endpoint_config_name: builtins.str,
     production_variants: typing.Sequence[typing.Union[ProductionVariant, typing.Dict[builtins.str, typing.Any]]],
-    kms_key: typing.Optional[_IKey_5f11635f] = None,
+    kms_key: typing.Optional[_IKeyRef_d4fc6ef3] = None,
     tags: typing.Optional[_TaskInput_91b91b91] = None,
     result_path: typing.Optional[builtins.str] = None,
     result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
@@ -92693,7 +94847,7 @@ def _typecheckingstub__a04e5ec2f31c1c0a35206acfad542ed8d379ff952def62aaa6117a96e
     *,
     endpoint_config_name: builtins.str,
     production_variants: typing.Sequence[typing.Union[ProductionVariant, typing.Dict[builtins.str, typing.Any]]],
-    kms_key: typing.Optional[_IKey_5f11635f] = None,
+    kms_key: typing.Optional[_IKeyRef_d4fc6ef3] = None,
     tags: typing.Optional[_TaskInput_91b91b91] = None,
     comment: typing.Optional[builtins.str] = None,
     query_language: typing.Optional[_QueryLanguage_be8414a8] = None,
@@ -92716,7 +94870,7 @@ def _typecheckingstub__ba6ef12807fb03dd6a1e2b7b7459ab46a68375ac4bdd5c6889009eb09
     *,
     endpoint_config_name: builtins.str,
     production_variants: typing.Sequence[typing.Union[ProductionVariant, typing.Dict[builtins.str, typing.Any]]],
-    kms_key: typing.Optional[_IKey_5f11635f] = None,
+    kms_key: typing.Optional[_IKeyRef_d4fc6ef3] = None,
     tags: typing.Optional[_TaskInput_91b91b91] = None,
     result_path: typing.Optional[builtins.str] = None,
     result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
@@ -92754,7 +94908,7 @@ def _typecheckingstub__0340e22743e5cec55b8355716928d646950cfb9f1d89788c54e7a89c8
     result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
     endpoint_config_name: builtins.str,
     production_variants: typing.Sequence[typing.Union[ProductionVariant, typing.Dict[builtins.str, typing.Any]]],
-    kms_key: typing.Optional[_IKey_5f11635f] = None,
+    kms_key: typing.Optional[_IKeyRef_d4fc6ef3] = None,
     tags: typing.Optional[_TaskInput_91b91b91] = None,
 ) -> None:
     """Type checking stubs"""
@@ -92775,7 +94929,7 @@ def _typecheckingstub__224ee8de6923ad7c2b27d51fa022d67ec84732124bab2297a739557a9
     outputs: typing.Any = None,
     endpoint_config_name: builtins.str,
     production_variants: typing.Sequence[typing.Union[ProductionVariant, typing.Dict[builtins.str, typing.Any]]],
-    kms_key: typing.Optional[_IKey_5f11635f] = None,
+    kms_key: typing.Optional[_IKeyRef_d4fc6ef3] = None,
     tags: typing.Optional[_TaskInput_91b91b91] = None,
 ) -> None:
     """Type checking stubs"""
@@ -92800,7 +94954,7 @@ def _typecheckingstub__1d1471e23ddcae3c4722c429827c5dc0c982af6428c9ffd8f2f2d5418
     result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
     endpoint_config_name: builtins.str,
     production_variants: typing.Sequence[typing.Union[ProductionVariant, typing.Dict[builtins.str, typing.Any]]],
-    kms_key: typing.Optional[_IKey_5f11635f] = None,
+    kms_key: typing.Optional[_IKeyRef_d4fc6ef3] = None,
     tags: typing.Optional[_TaskInput_91b91b91] = None,
 ) -> None:
     """Type checking stubs"""
@@ -94218,6 +96372,14 @@ def _typecheckingstub__7f029a86ecd789f9746de04e831dd00fa385ff16eff9e460e283675c6
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__682a3d293d520e48cda4b322d7a11a901469838caf114187b949c74301eba9a0(
+    *,
+    bucket: _IBucket_42e086fd,
+    path: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__3876aeec1b0e2570c479d15f510b9f85e418ae931e5d26b863e809248e9c1102(
     *,
     s3_data_source: typing.Union[TransformS3DataSource, typing.Dict[builtins.str, typing.Any]],
@@ -94240,7 +96402,7 @@ def _typecheckingstub__e0cf6576f3c404e22a16992178f88fbe3f245d07212e6cb4794473e5a
     s3_output_path: builtins.str,
     accept: typing.Optional[builtins.str] = None,
     assemble_with: typing.Optional[AssembleWith] = None,
-    encryption_key: typing.Optional[_IKey_5f11635f] = None,
+    encryption_key: typing.Optional[_IKeyRef_d4fc6ef3] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -94249,7 +96411,7 @@ def _typecheckingstub__30e58d94548c5ccbec0d0beebb0cb5f0b52fadefbe7e2baccc25f98ae
     *,
     instance_count: jsii.Number,
     instance_type: _InstanceType_f64915b9,
-    volume_encryption_key: typing.Optional[_IKey_5f11635f] = None,
+    volume_encryption_key: typing.Optional[_IKeyRef_d4fc6ef3] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -94262,6 +96424,14 @@ def _typecheckingstub__1bf67112cc77948d7e9195d0722cf1a2657ff1a785c74e905b6fd8f05
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__a6205038f5bd369810feab5dd42ebc706a68c088fceea69b083c4878117ca890(
+    *,
+    bucket: _IBucket_42e086fd,
+    path: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__5613dfd7586032cb8014fb82727b538f19d6ad8e354293fb9634b6eb82082c5d(
     task_input: _TaskInput_91b91b91,
 ) -> None:
@@ -94414,7 +96584,7 @@ def _typecheckingstub__a8584021dc58453ae786ca7a6b0d6b228d99e24e96189ad9dd7ce18d3
     pass
 
 def _typecheckingstub__193210761ae10b68dfdc04ae454b8c432675bc12145b65077c7c23ee6f35daa2(
-    _task: EcsRunTask,
+    task: EcsRunTask,
     *,
     task_definition: _ITaskDefinition_889ba4d8,
     cluster: typing.Optional[_ICluster_16cddd09] = None,
@@ -94423,10 +96593,13 @@ def _typecheckingstub__193210761ae10b68dfdc04ae454b8c432675bc12145b65077c7c23ee6
     pass
 
 def _typecheckingstub__7c19025da4101b4b8d2482e0216270cc5e94fe58381fdba0b4cf99f04e2776b9(
-    _task: EcsRunTask,
+    task: EcsRunTask,
     *,
     task_definition: _ITaskDefinition_889ba4d8,
     cluster: typing.Optional[_ICluster_16cddd09] = None,
 ) -> None:
     """Type checking stubs"""
     pass
+
+for cls in [IBedrockCreateModelCustomizationJobVpcConfig, IContainerDefinition, IEcsLaunchTarget, ISageMakerTask]:
+    typing.cast(typing.Any, cls).__protocol_attrs__ = typing.cast(typing.Any, cls).__protocol_attrs__ - set(['__jsii_proxy_class__', '__jsii_type__'])