aws-cdk-lib 2.198.0__py3-none-any.whl → 2.199.0__py3-none-any.whl

aws_cdk/aws_stepfunctions_tasks/__init__.py

@@ -40,9 +40,11 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
   * [Bedrock](#bedrock)
 
     * [InvokeModel](#invokemodel)
+    * [createModelCustomizationJob](#createmodelcustomizationjob)
   * [CodeBuild](#codebuild)
 
     * [StartBuild](#startbuild)
+    * [StartBuildBatch](#startbuildbatch)
   * [DynamoDB](#dynamodb)
 
     * [GetItem](#getitem)
@@ -55,6 +57,7 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
 
       * [EC2](#ec2)
       * [Fargate](#fargate)
+      * [ECS enable Exec](#ecs-enable-exec)
   * [EMR](#emr)
 
     * [Create Cluster](#create-cluster)
@@ -77,8 +80,8 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
     * [Put Events](#put-events)
   * [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)
@@ -510,6 +513,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.
@@ -2018,6 +2071,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,
@@ -9826,6 +9880,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[_IRole_235f5d8e] = 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[_IRole_235f5d8e] = 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[_IRole_235f5d8e]:
+        '''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[_IRole_235f5d8e], 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,
@@ -21962,6 +22801,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=[],
@@ -61950,6 +62994,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.
@@ -65713,6 +66813,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=[],
@@ -82885,6 +84088,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=[],
@@ -83424,6 +84730,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",
@@ -85804,6 +87183,8 @@ __all__ = [
     "BatchSubmitJobJsonPathProps",
     "BatchSubmitJobJsonataProps",
     "BatchSubmitJobProps",
+    "BedrockCreateModelCustomizationJob",
+    "BedrockCreateModelCustomizationJobProps",
     "BedrockInvokeModel",
     "BedrockInvokeModelInputProps",
     "BedrockInvokeModelJsonPathProps",
@@ -85850,6 +87231,9 @@ __all__ = [
     "ContainerOverride",
     "ContainerOverrides",
     "CronOptions",
+    "CustomModelTag",
+    "CustomizationType",
+    "DataBucketConfiguration",
     "DataSource",
     "DockerImage",
     "DockerImageConfig",
@@ -85963,6 +87347,7 @@ __all__ = [
     "HttpInvokeProps",
     "HttpMethod",
     "HttpMethods",
+    "IBedrockCreateModelCustomizationJobVpcConfig",
     "IContainerDefinition",
     "IEcsLaunchTarget",
     "ISageMakerTask",
@@ -85985,6 +87370,7 @@ __all__ = [
     "Mode",
     "ModelClientOptions",
     "Monitoring",
+    "OutputBucketConfiguration",
     "OutputDataConfig",
     "ProductionVariant",
     "QueryExecutionContext",
@@ -86045,12 +87431,14 @@ __all__ = [
     "StepFunctionsStartExecutionProps",
     "StoppingCondition",
     "TaskEnvironmentVariable",
+    "TrainingBucketConfiguration",
     "TransformDataSource",
     "TransformInput",
     "TransformOutput",
     "TransformResources",
     "TransformS3DataSource",
     "URLEncodingFormat",
+    "ValidationBucketConfiguration",
     "VirtualClusterInput",
     "VpcConfig",
     "WorkerConfigurationProperty",
@@ -86854,6 +88242,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[_IRole_235f5d8e] = 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[_IRole_235f5d8e] = 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,
@@ -88074,6 +89534,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]],
@@ -92516,6 +93992,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,
@@ -94254,6 +95738,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]],
@@ -94298,6 +95790,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: