aws-cdk-lib 2.132.1__py3-none-any.whl → 2.134.0__py3-none-any.whl

aws_cdk/aws_stepfunctions_tasks/__init__.py

@@ -74,8 +74,15 @@ 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)
   * [Glue DataBrew](#glue-databrew)
+
+    * [Start Job Run](#start-job-run-1)
   * [Lambda](#lambda)
+
+    * [Invoke](#invoke)
   * [SageMaker](#sagemaker)
 
     * [Create Training Job](#create-training-job)
@@ -85,12 +92,16 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
     * [Create Model](#create-model)
     * [Update Endpoint](#update-endpoint)
   * [SNS](#sns)
+
+    * [Publish](#publish)
   * [Step Functions](#step-functions)
 
     * [Start Execution](#start-execution)
     * [Invoke Activity](#invoke-activity)
   * [SQS](#sqs)
 
+    * [Send Message](#send-message)
+
 ## Paths
 
 Learn more about input and output processing in Step Functions [here](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-input-output-filtering.html)
@@ -1094,6 +1105,8 @@ tasks.EventBridgePutEvents(self, "Send an event to EventBridge",
 
 Step Functions supports [AWS Glue](https://docs.aws.amazon.com/step-functions/latest/dg/connect-glue.html) through the service integration pattern.
 
+### StartJobRun
+
 You can call the [`StartJobRun`](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-runs.html#aws-glue-api-jobs-runs-StartJobRun) API from a `Task` state.
 
 ```python
@@ -1107,10 +1120,33 @@ tasks.GlueStartJobRun(self, "Task",
 )
 ```
 
+### StartCrawlerRun
+
+You can call the [`StartCrawler`](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-crawling.html#aws-glue-api-crawler-crawling-StartCrawler) API from a `Task` state through AWS SDK service integrations.
+
+```python
+import aws_cdk.aws_glue as glue
+
+# my_crawler: glue.CfnCrawler
+
+
+# You can get the crawler name from `crawler.ref`
+tasks.GlueStartCrawlerRun(self, "Task1",
+    crawler_name=my_crawler.ref
+)
+
+# Of course, you can also specify the crawler name directly.
+tasks.GlueStartCrawlerRun(self, "Task2",
+    crawler_name="my-crawler-job"
+)
+```
+
 ## Glue DataBrew
 
 Step Functions supports [AWS Glue DataBrew](https://docs.aws.amazon.com/step-functions/latest/dg/connect-databrew.html) through the service integration pattern.
 
+### Start Job Run
+
 You can call the [`StartJobRun`](https://docs.aws.amazon.com/databrew/latest/dg/API_StartJobRun.html) API from a `Task` state.
 
 ```python
@@ -1121,6 +1157,10 @@ tasks.GlueDataBrewStartJobRun(self, "Task",
 
 ## Lambda
 
+Step Functions supports [AWS Lambda](https://docs.aws.amazon.com/step-functions/latest/dg/connect-lambda.html) through the service integration pattern.
+
+### Invoke
+
 [Invoke](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html) a Lambda function.
 
 You can specify the input to your Lambda function through the `payload` attribute.
@@ -1359,6 +1399,8 @@ tasks.SageMakerUpdateEndpoint(self, "SagemakerEndpoint",
 
 Step Functions supports [Amazon SNS](https://docs.aws.amazon.com/step-functions/latest/dg/connect-sns.html) through the service integration pattern.
 
+### Publish
+
 You can call the [`Publish`](https://docs.aws.amazon.com/sns/latest/api/API_Publish.html) API from a `Task` state to publish to an SNS topic.
 
 ```python
@@ -1400,6 +1442,8 @@ task2 = tasks.SnsPublish(self, "Publish2",
 
 ## Step Functions
 
+Step Functions supports [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/connect-stepfunctions.html) through the service integration pattern.
+
 ### Start Execution
 
 You can manage [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/connect-stepfunctions.html) executions.
@@ -1496,6 +1540,8 @@ tasks.StepFunctionsInvokeActivity(self, "Submit Job",
 
 Step Functions supports [Amazon SQS](https://docs.aws.amazon.com/step-functions/latest/dg/connect-sqs.html)
 
+### Send Message
+
 You can call the [`SendMessage`](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html) API from a `Task` state
 to send a message to an SQS queue.
 
@@ -22573,6 +22619,394 @@ class GlueDataBrewStartJobRunProps(_TaskStateBaseProps_3a62b6d0):
         )
 
 
+class GlueStartCrawlerRun(
+    _TaskStateBase_b5c0a816,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.GlueStartCrawlerRun",
+):
+    '''Starts an AWS Glue Crawler in a Task state.
+
+    :see: https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-crawling.html#aws-glue-api-crawler-crawling-StartCrawler
+    :exampleMetadata: infused
+
+    Example::
+
+        import aws_cdk.aws_glue as glue
+        
+        # my_crawler: glue.CfnCrawler
+        
+        
+        # You can get the crawler name from `crawler.ref`
+        tasks.GlueStartCrawlerRun(self, "Task1",
+            crawler_name=my_crawler.ref
+        )
+        
+        # Of course, you can also specify the crawler name directly.
+        tasks.GlueStartCrawlerRun(self, "Task2",
+            crawler_name="my-crawler-job"
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        crawler_name: builtins.str,
+        comment: typing.Optional[builtins.str] = None,
+        credentials: typing.Optional[typing.Union[_Credentials_2cd64c6b, typing.Dict[builtins.str, typing.Any]]] = None,
+        heartbeat: typing.Optional[_Duration_4839e8c3] = None,
+        heartbeat_timeout: typing.Optional[_Timeout_d7c10551] = None,
+        input_path: typing.Optional[builtins.str] = None,
+        integration_pattern: typing.Optional[_IntegrationPattern_949291bc] = None,
+        output_path: typing.Optional[builtins.str] = None,
+        result_path: typing.Optional[builtins.str] = None,
+        result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+        state_name: typing.Optional[builtins.str] = None,
+        task_timeout: typing.Optional[_Timeout_d7c10551] = None,
+        timeout: typing.Optional[_Duration_4839e8c3] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param id: Descriptive identifier for this chainable.
+        :param crawler_name: Glue crawler name.
+        :param comment: An optional description for this state. Default: - No comment
+        :param credentials: Credentials for an IAM Role that the State Machine assumes for executing the task. This enables cross-account resource invocations. Default: - None (Task is executed using the State Machine's execution role)
+        :param heartbeat: (deprecated) Timeout for the heartbeat. Default: - None
+        :param heartbeat_timeout: Timeout for the heartbeat. [disable-awslint:duration-prop-type] is needed because all props interface in aws-stepfunctions-tasks extend this interface Default: - None
+        :param input_path: JSONPath expression to select part of the state to be the input to this state. May also be the special value JsonPath.DISCARD, which will cause the effective input to be the empty object {}. Default: - The entire task input (JSON path '$')
+        :param integration_pattern: AWS Step Functions integrates with services directly in the Amazon States Language. You can control these AWS services using service integration patterns. Depending on the AWS Service, the Service Integration Pattern availability will vary. Default: - ``IntegrationPattern.REQUEST_RESPONSE`` for most tasks. ``IntegrationPattern.RUN_JOB`` for the following exceptions: ``BatchSubmitJob``, ``EmrAddStep``, ``EmrCreateCluster``, ``EmrTerminationCluster``, and ``EmrContainersStartJobRun``.
+        :param output_path: JSONPath expression to select select a portion of the state output to pass to the next state. May also be the special value JsonPath.DISCARD, which will cause the effective output to be the empty object {}. Default: - The entire JSON node determined by the state input, the task result, and resultPath is passed to the next state (JSON path '$')
+        :param result_path: JSONPath expression to indicate where to inject the state's output. May also be the special value JsonPath.DISCARD, which will cause the state's input to become its output. Default: - Replaces the entire input with the result (JSON path '$')
+        :param result_selector: The JSON that will replace the state's raw result and become the effective result before ResultPath is applied. You can use ResultSelector to create a payload with values that are static or selected from the state's raw result. Default: - None
+        :param state_name: Optional name for this state. Default: - The construct ID will be used as state name
+        :param task_timeout: Timeout for the task. [disable-awslint:duration-prop-type] is needed because all props interface in aws-stepfunctions-tasks extend this interface Default: - None
+        :param timeout: (deprecated) Timeout for the task. Default: - None
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__f264cba7fa19bf21bd67a0cf04f41bbacf1af0b407e6f101ed1cba13bca77418)
+            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 = GlueStartCrawlerRunProps(
+            crawler_name=crawler_name,
+            comment=comment,
+            credentials=credentials,
+            heartbeat=heartbeat,
+            heartbeat_timeout=heartbeat_timeout,
+            input_path=input_path,
+            integration_pattern=integration_pattern,
+            output_path=output_path,
+            result_path=result_path,
+            result_selector=result_selector,
+            state_name=state_name,
+            task_timeout=task_timeout,
+            timeout=timeout,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @builtins.property
+    @jsii.member(jsii_name="taskMetrics")
+    def _task_metrics(self) -> typing.Optional[_TaskMetricsConfig_32ea9403]:
+        return typing.cast(typing.Optional[_TaskMetricsConfig_32ea9403], jsii.get(self, "taskMetrics"))
+
+    @builtins.property
+    @jsii.member(jsii_name="taskPolicies")
+    def _task_policies(self) -> typing.Optional[typing.List[_PolicyStatement_0fe33853]]:
+        return typing.cast(typing.Optional[typing.List[_PolicyStatement_0fe33853]], jsii.get(self, "taskPolicies"))
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.GlueStartCrawlerRunProps",
+    jsii_struct_bases=[_TaskStateBaseProps_3a62b6d0],
+    name_mapping={
+        "comment": "comment",
+        "credentials": "credentials",
+        "heartbeat": "heartbeat",
+        "heartbeat_timeout": "heartbeatTimeout",
+        "input_path": "inputPath",
+        "integration_pattern": "integrationPattern",
+        "output_path": "outputPath",
+        "result_path": "resultPath",
+        "result_selector": "resultSelector",
+        "state_name": "stateName",
+        "task_timeout": "taskTimeout",
+        "timeout": "timeout",
+        "crawler_name": "crawlerName",
+    },
+)
+class GlueStartCrawlerRunProps(_TaskStateBaseProps_3a62b6d0):
+    def __init__(
+        self,
+        *,
+        comment: typing.Optional[builtins.str] = None,
+        credentials: typing.Optional[typing.Union[_Credentials_2cd64c6b, typing.Dict[builtins.str, typing.Any]]] = None,
+        heartbeat: typing.Optional[_Duration_4839e8c3] = None,
+        heartbeat_timeout: typing.Optional[_Timeout_d7c10551] = None,
+        input_path: typing.Optional[builtins.str] = None,
+        integration_pattern: typing.Optional[_IntegrationPattern_949291bc] = None,
+        output_path: typing.Optional[builtins.str] = None,
+        result_path: typing.Optional[builtins.str] = None,
+        result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+        state_name: typing.Optional[builtins.str] = None,
+        task_timeout: typing.Optional[_Timeout_d7c10551] = None,
+        timeout: typing.Optional[_Duration_4839e8c3] = None,
+        crawler_name: builtins.str,
+    ) -> None:
+        '''Properties for starting an AWS Glue Crawler as a task.
+
+        :param comment: An optional description for this state. Default: - No comment
+        :param credentials: Credentials for an IAM Role that the State Machine assumes for executing the task. This enables cross-account resource invocations. Default: - None (Task is executed using the State Machine's execution role)
+        :param heartbeat: (deprecated) Timeout for the heartbeat. Default: - None
+        :param heartbeat_timeout: Timeout for the heartbeat. [disable-awslint:duration-prop-type] is needed because all props interface in aws-stepfunctions-tasks extend this interface Default: - None
+        :param input_path: JSONPath expression to select part of the state to be the input to this state. May also be the special value JsonPath.DISCARD, which will cause the effective input to be the empty object {}. Default: - The entire task input (JSON path '$')
+        :param integration_pattern: AWS Step Functions integrates with services directly in the Amazon States Language. You can control these AWS services using service integration patterns. Depending on the AWS Service, the Service Integration Pattern availability will vary. Default: - ``IntegrationPattern.REQUEST_RESPONSE`` for most tasks. ``IntegrationPattern.RUN_JOB`` for the following exceptions: ``BatchSubmitJob``, ``EmrAddStep``, ``EmrCreateCluster``, ``EmrTerminationCluster``, and ``EmrContainersStartJobRun``.
+        :param output_path: JSONPath expression to select select a portion of the state output to pass to the next state. May also be the special value JsonPath.DISCARD, which will cause the effective output to be the empty object {}. Default: - The entire JSON node determined by the state input, the task result, and resultPath is passed to the next state (JSON path '$')
+        :param result_path: JSONPath expression to indicate where to inject the state's output. May also be the special value JsonPath.DISCARD, which will cause the state's input to become its output. Default: - Replaces the entire input with the result (JSON path '$')
+        :param result_selector: The JSON that will replace the state's raw result and become the effective result before ResultPath is applied. You can use ResultSelector to create a payload with values that are static or selected from the state's raw result. Default: - None
+        :param state_name: Optional name for this state. Default: - The construct ID will be used as state name
+        :param task_timeout: Timeout for the task. [disable-awslint:duration-prop-type] is needed because all props interface in aws-stepfunctions-tasks extend this interface Default: - None
+        :param timeout: (deprecated) Timeout for the task. Default: - None
+        :param crawler_name: Glue crawler name.
+
+        :exampleMetadata: infused
+
+        Example::
+
+            import aws_cdk.aws_glue as glue
+            
+            # my_crawler: glue.CfnCrawler
+            
+            
+            # You can get the crawler name from `crawler.ref`
+            tasks.GlueStartCrawlerRun(self, "Task1",
+                crawler_name=my_crawler.ref
+            )
+            
+            # Of course, you can also specify the crawler name directly.
+            tasks.GlueStartCrawlerRun(self, "Task2",
+                crawler_name="my-crawler-job"
+            )
+        '''
+        if isinstance(credentials, dict):
+            credentials = _Credentials_2cd64c6b(**credentials)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__dce10d315644e09a3651f49bd35f96d0ecdc7bf8a7a81ce4cfd669d1f21f0b0e)
+            check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
+            check_type(argname="argument credentials", value=credentials, expected_type=type_hints["credentials"])
+            check_type(argname="argument heartbeat", value=heartbeat, expected_type=type_hints["heartbeat"])
+            check_type(argname="argument heartbeat_timeout", value=heartbeat_timeout, expected_type=type_hints["heartbeat_timeout"])
+            check_type(argname="argument input_path", value=input_path, expected_type=type_hints["input_path"])
+            check_type(argname="argument integration_pattern", value=integration_pattern, expected_type=type_hints["integration_pattern"])
+            check_type(argname="argument output_path", value=output_path, expected_type=type_hints["output_path"])
+            check_type(argname="argument result_path", value=result_path, expected_type=type_hints["result_path"])
+            check_type(argname="argument result_selector", value=result_selector, expected_type=type_hints["result_selector"])
+            check_type(argname="argument state_name", value=state_name, expected_type=type_hints["state_name"])
+            check_type(argname="argument task_timeout", value=task_timeout, expected_type=type_hints["task_timeout"])
+            check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
+            check_type(argname="argument crawler_name", value=crawler_name, expected_type=type_hints["crawler_name"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "crawler_name": crawler_name,
+        }
+        if comment is not None:
+            self._values["comment"] = comment
+        if credentials is not None:
+            self._values["credentials"] = credentials
+        if heartbeat is not None:
+            self._values["heartbeat"] = heartbeat
+        if heartbeat_timeout is not None:
+            self._values["heartbeat_timeout"] = heartbeat_timeout
+        if input_path is not None:
+            self._values["input_path"] = input_path
+        if integration_pattern is not None:
+            self._values["integration_pattern"] = integration_pattern
+        if output_path is not None:
+            self._values["output_path"] = output_path
+        if result_path is not None:
+            self._values["result_path"] = result_path
+        if result_selector is not None:
+            self._values["result_selector"] = result_selector
+        if state_name is not None:
+            self._values["state_name"] = state_name
+        if task_timeout is not None:
+            self._values["task_timeout"] = task_timeout
+        if timeout is not None:
+            self._values["timeout"] = timeout
+
+    @builtins.property
+    def comment(self) -> typing.Optional[builtins.str]:
+        '''An optional description for this state.
+
+        :default: - No comment
+        '''
+        result = self._values.get("comment")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def credentials(self) -> typing.Optional[_Credentials_2cd64c6b]:
+        '''Credentials for an IAM Role that the State Machine assumes for executing the task.
+
+        This enables cross-account resource invocations.
+
+        :default: - None (Task is executed using the State Machine's execution role)
+
+        :see: https://docs.aws.amazon.com/step-functions/latest/dg/concepts-access-cross-acct-resources.html
+        '''
+        result = self._values.get("credentials")
+        return typing.cast(typing.Optional[_Credentials_2cd64c6b], result)
+
+    @builtins.property
+    def heartbeat(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''(deprecated) Timeout for the heartbeat.
+
+        :default: - None
+
+        :deprecated: use ``heartbeatTimeout``
+
+        :stability: deprecated
+        '''
+        result = self._values.get("heartbeat")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
+    @builtins.property
+    def heartbeat_timeout(self) -> typing.Optional[_Timeout_d7c10551]:
+        '''Timeout for the heartbeat.
+
+        [disable-awslint:duration-prop-type] is needed because all props interface in
+        aws-stepfunctions-tasks extend this interface
+
+        :default: - None
+        '''
+        result = self._values.get("heartbeat_timeout")
+        return typing.cast(typing.Optional[_Timeout_d7c10551], result)
+
+    @builtins.property
+    def input_path(self) -> typing.Optional[builtins.str]:
+        '''JSONPath expression to select part of the state to be the input to this state.
+
+        May also be the special value JsonPath.DISCARD, which will cause the effective
+        input to be the empty object {}.
+
+        :default: - The entire task input (JSON path '$')
+        '''
+        result = self._values.get("input_path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def integration_pattern(self) -> typing.Optional[_IntegrationPattern_949291bc]:
+        '''AWS Step Functions integrates with services directly in the Amazon States Language.
+
+        You can control these AWS services using service integration patterns.
+
+        Depending on the AWS Service, the Service Integration Pattern availability will vary.
+
+        :default:
+
+        - ``IntegrationPattern.REQUEST_RESPONSE`` for most tasks.
+        ``IntegrationPattern.RUN_JOB`` for the following exceptions:
+        ``BatchSubmitJob``, ``EmrAddStep``, ``EmrCreateCluster``, ``EmrTerminationCluster``, and ``EmrContainersStartJobRun``.
+
+        :see: https://docs.aws.amazon.com/step-functions/latest/dg/connect-supported-services.html
+        '''
+        result = self._values.get("integration_pattern")
+        return typing.cast(typing.Optional[_IntegrationPattern_949291bc], result)
+
+    @builtins.property
+    def output_path(self) -> typing.Optional[builtins.str]:
+        '''JSONPath expression to select select a portion of the state output to pass to the next state.
+
+        May also be the special value JsonPath.DISCARD, which will cause the effective
+        output to be the empty object {}.
+
+        :default:
+
+        - The entire JSON node determined by the state input, the task result,
+        and resultPath is passed to the next state (JSON path '$')
+        '''
+        result = self._values.get("output_path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def result_path(self) -> typing.Optional[builtins.str]:
+        '''JSONPath expression to indicate where to inject the state's output.
+
+        May also be the special value JsonPath.DISCARD, which will cause the state's
+        input to become its output.
+
+        :default: - Replaces the entire input with the result (JSON path '$')
+        '''
+        result = self._values.get("result_path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def result_selector(
+        self,
+    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
+        '''The JSON that will replace the state's raw result and become the effective result before ResultPath is applied.
+
+        You can use ResultSelector to create a payload with values that are static
+        or selected from the state's raw result.
+
+        :default: - None
+
+        :see: https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-resultselector
+        '''
+        result = self._values.get("result_selector")
+        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)
+
+    @builtins.property
+    def state_name(self) -> typing.Optional[builtins.str]:
+        '''Optional name for this state.
+
+        :default: - The construct ID will be used as state name
+        '''
+        result = self._values.get("state_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def task_timeout(self) -> typing.Optional[_Timeout_d7c10551]:
+        '''Timeout for the task.
+
+        [disable-awslint:duration-prop-type] is needed because all props interface in
+        aws-stepfunctions-tasks extend this interface
+
+        :default: - None
+        '''
+        result = self._values.get("task_timeout")
+        return typing.cast(typing.Optional[_Timeout_d7c10551], result)
+
+    @builtins.property
+    def timeout(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''(deprecated) Timeout for the task.
+
+        :default: - None
+
+        :deprecated: use ``taskTimeout``
+
+        :stability: deprecated
+        '''
+        result = self._values.get("timeout")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
+    @builtins.property
+    def crawler_name(self) -> builtins.str:
+        '''Glue crawler name.'''
+        result = self._values.get("crawler_name")
+        assert result is not None, "Required property 'crawler_name' is missing"
+        return typing.cast(builtins.str, result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "GlueStartCrawlerRunProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 class GlueStartJobRun(
     _TaskStateBase_b5c0a816,
     metaclass=jsii.JSIIMeta,
@@ -31674,6 +32108,8 @@ __all__ = [
     "EventBridgePutEventsProps",
     "GlueDataBrewStartJobRun",
     "GlueDataBrewStartJobRunProps",
+    "GlueStartCrawlerRun",
+    "GlueStartCrawlerRunProps",
     "GlueStartJobRun",
     "GlueStartJobRunProps",
     "HttpMethod",
@@ -33845,6 +34281,46 @@ def _typecheckingstub__69a84c7e673f8f3a1038e40920094e0954ed3fead8b2f4b7c569c20e5
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__f264cba7fa19bf21bd67a0cf04f41bbacf1af0b407e6f101ed1cba13bca77418(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    crawler_name: builtins.str,
+    comment: typing.Optional[builtins.str] = None,
+    credentials: typing.Optional[typing.Union[_Credentials_2cd64c6b, typing.Dict[builtins.str, typing.Any]]] = None,
+    heartbeat: typing.Optional[_Duration_4839e8c3] = None,
+    heartbeat_timeout: typing.Optional[_Timeout_d7c10551] = None,
+    input_path: typing.Optional[builtins.str] = None,
+    integration_pattern: typing.Optional[_IntegrationPattern_949291bc] = None,
+    output_path: typing.Optional[builtins.str] = None,
+    result_path: typing.Optional[builtins.str] = None,
+    result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+    state_name: typing.Optional[builtins.str] = None,
+    task_timeout: typing.Optional[_Timeout_d7c10551] = None,
+    timeout: typing.Optional[_Duration_4839e8c3] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__dce10d315644e09a3651f49bd35f96d0ecdc7bf8a7a81ce4cfd669d1f21f0b0e(
+    *,
+    comment: typing.Optional[builtins.str] = None,
+    credentials: typing.Optional[typing.Union[_Credentials_2cd64c6b, typing.Dict[builtins.str, typing.Any]]] = None,
+    heartbeat: typing.Optional[_Duration_4839e8c3] = None,
+    heartbeat_timeout: typing.Optional[_Timeout_d7c10551] = None,
+    input_path: typing.Optional[builtins.str] = None,
+    integration_pattern: typing.Optional[_IntegrationPattern_949291bc] = None,
+    output_path: typing.Optional[builtins.str] = None,
+    result_path: typing.Optional[builtins.str] = None,
+    result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+    state_name: typing.Optional[builtins.str] = None,
+    task_timeout: typing.Optional[_Timeout_d7c10551] = None,
+    timeout: typing.Optional[_Duration_4839e8c3] = None,
+    crawler_name: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__ca53b69e05a043466b0fb8d683b8908756bbb80a6167bf6e801b2cc4b3f2603a(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,