aws-cdk-lib 2.167.1__py3-none-any.whl → 2.168.0__py3-none-any.whl

aws_cdk/aws_stepfunctions_tasks/__init__.py

@@ -1292,6 +1292,62 @@ tasks.EventBridgePutEvents(self, "Send an event to EventBridge",
 )
 ```
 
+## EventBridge Scheduler
+
+You can call EventBridge Scheduler APIs from a `Task` state.
+Read more about calling Scheduler APIs [here](https://docs.aws.amazon.com/scheduler/latest/APIReference/API_Operations.html)
+
+### Create Scheduler
+
+The [CreateSchedule](https://docs.aws.amazon.com/scheduler/latest/APIReference/API_CreateSchedule.html) API creates a new schedule.
+
+Here is an example of how to create a schedule that puts an event to SQS queue every 5 minutes:
+
+```python
+import aws_cdk.aws_scheduler as scheduler
+import aws_cdk.aws_kms as kms
+
+# key: kms.Key
+# schedule_group: scheduler.CfnScheduleGroup
+# target_queue: sqs.Queue
+# dead_letter_queue: sqs.Queue
+
+
+scheduler_role = iam.Role(self, "SchedulerRole",
+    assumed_by=iam.ServicePrincipal("scheduler.amazonaws.com")
+)
+# To send the message to the queue
+# This policy changes depending on the type of target.
+scheduler_role.add_to_principal_policy(iam.PolicyStatement(
+    actions=["sqs:SendMessage"],
+    resources=[target_queue.queue_arn]
+))
+
+create_schedule_task1 = tasks.EventBridgeSchedulerCreateScheduleTask(self, "createSchedule",
+    schedule_name="TestSchedule",
+    action_after_completion=tasks.ActionAfterCompletion.NONE,
+    client_token="testToken",
+    description="TestDescription",
+    start_date=Date(),
+    end_date=Date(Date().get_time() + 1000 * 60 * 60),
+    flexible_time_window=Duration.minutes(5),
+    group_name=schedule_group.ref,
+    kms_key=key,
+    schedule=tasks.Schedule.rate(Duration.minutes(5)),
+    timezone="UTC",
+    enabled=True,
+    target=tasks.EventBridgeSchedulerTarget(
+        arn=target_queue.queue_arn,
+        role=scheduler_role,
+        retry_policy=tasks.RetryPolicy(
+            maximum_retry_attempts=2,
+            maximum_event_age=Duration.minutes(5)
+        ),
+        dead_letter_queue=dead_letter_queue
+    )
+)
+```
+
 ## Glue
 
 Step Functions supports [AWS Glue](https://docs.aws.amazon.com/step-functions/latest/dg/connect-glue.html) through the service integration pattern.
@@ -2082,6 +2138,64 @@ class AcceleratorType(
         return typing.cast(builtins.str, jsii.invoke(self, "toString", []))
 
 
+@jsii.enum(jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.ActionAfterCompletion")
+class ActionAfterCompletion(enum.Enum):
+    '''The action that EventBridge Scheduler applies to the schedule after the schedule completes invoking the target.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        import aws_cdk.aws_scheduler as scheduler
+        import aws_cdk.aws_kms as kms
+        
+        # key: kms.Key
+        # schedule_group: scheduler.CfnScheduleGroup
+        # target_queue: sqs.Queue
+        # dead_letter_queue: sqs.Queue
+        
+        
+        scheduler_role = iam.Role(self, "SchedulerRole",
+            assumed_by=iam.ServicePrincipal("scheduler.amazonaws.com")
+        )
+        # To send the message to the queue
+        # This policy changes depending on the type of target.
+        scheduler_role.add_to_principal_policy(iam.PolicyStatement(
+            actions=["sqs:SendMessage"],
+            resources=[target_queue.queue_arn]
+        ))
+        
+        create_schedule_task1 = tasks.EventBridgeSchedulerCreateScheduleTask(self, "createSchedule",
+            schedule_name="TestSchedule",
+            action_after_completion=tasks.ActionAfterCompletion.NONE,
+            client_token="testToken",
+            description="TestDescription",
+            start_date=Date(),
+            end_date=Date(Date().get_time() + 1000 * 60 * 60),
+            flexible_time_window=Duration.minutes(5),
+            group_name=schedule_group.ref,
+            kms_key=key,
+            schedule=tasks.Schedule.rate(Duration.minutes(5)),
+            timezone="UTC",
+            enabled=True,
+            target=tasks.EventBridgeSchedulerTarget(
+                arn=target_queue.queue_arn,
+                role=scheduler_role,
+                retry_policy=tasks.RetryPolicy(
+                    maximum_retry_attempts=2,
+                    maximum_event_age=Duration.minutes(5)
+                ),
+                dead_letter_queue=dead_letter_queue
+            )
+        )
+    '''
+
+    NONE = "NONE"
+    '''Takes no action.'''
+    DELETE = "DELETE"
+    '''Deletes the schedule.'''
+
+
 @jsii.enum(jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.ActionOnFailure")
 class ActionOnFailure(enum.Enum):
     '''The action to take when the cluster step fails.
@@ -9807,6 +9921,147 @@ class ContainerOverrides:
         )
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.CronOptions",
+    jsii_struct_bases=[],
+    name_mapping={
+        "day": "day",
+        "hour": "hour",
+        "minute": "minute",
+        "month": "month",
+        "week_day": "weekDay",
+        "year": "year",
+    },
+)
+class CronOptions:
+    def __init__(
+        self,
+        *,
+        day: typing.Optional[builtins.str] = None,
+        hour: typing.Optional[builtins.str] = None,
+        minute: typing.Optional[builtins.str] = None,
+        month: typing.Optional[builtins.str] = None,
+        week_day: typing.Optional[builtins.str] = None,
+        year: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''Options to configure a cron expression.
+
+        All fields are strings so you can use complex expressions. Absence of
+        a field implies '*' or '?', whichever one is appropriate.
+
+        :param day: The day of the month to run this rule at. Default: - Every day of the month
+        :param hour: The hour to run this rule at. Default: - Every hour
+        :param minute: The minute to run this rule at. Default: - Every minute
+        :param month: The month to run this rule at. Default: - Every month
+        :param week_day: The day of the week to run this rule at. Default: - Whichever day of the week that ``day`` falls on
+        :param year: The year to run this rule at. Default: - Every year
+
+        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Canaries_cron.html
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            from aws_cdk import aws_stepfunctions_tasks as stepfunctions_tasks
+            
+            cron_options = stepfunctions_tasks.CronOptions(
+                day="day",
+                hour="hour",
+                minute="minute",
+                month="month",
+                week_day="weekDay",
+                year="year"
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__3ded07e1f80001916cedf33047f0de79b459fade9caa718d154ce12553ccfd4b)
+            check_type(argname="argument day", value=day, expected_type=type_hints["day"])
+            check_type(argname="argument hour", value=hour, expected_type=type_hints["hour"])
+            check_type(argname="argument minute", value=minute, expected_type=type_hints["minute"])
+            check_type(argname="argument month", value=month, expected_type=type_hints["month"])
+            check_type(argname="argument week_day", value=week_day, expected_type=type_hints["week_day"])
+            check_type(argname="argument year", value=year, expected_type=type_hints["year"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if day is not None:
+            self._values["day"] = day
+        if hour is not None:
+            self._values["hour"] = hour
+        if minute is not None:
+            self._values["minute"] = minute
+        if month is not None:
+            self._values["month"] = month
+        if week_day is not None:
+            self._values["week_day"] = week_day
+        if year is not None:
+            self._values["year"] = year
+
+    @builtins.property
+    def day(self) -> typing.Optional[builtins.str]:
+        '''The day of the month to run this rule at.
+
+        :default: - Every day of the month
+        '''
+        result = self._values.get("day")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def hour(self) -> typing.Optional[builtins.str]:
+        '''The hour to run this rule at.
+
+        :default: - Every hour
+        '''
+        result = self._values.get("hour")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def minute(self) -> typing.Optional[builtins.str]:
+        '''The minute to run this rule at.
+
+        :default: - Every minute
+        '''
+        result = self._values.get("minute")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def month(self) -> typing.Optional[builtins.str]:
+        '''The month to run this rule at.
+
+        :default: - Every month
+        '''
+        result = self._values.get("month")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def week_day(self) -> typing.Optional[builtins.str]:
+        '''The day of the week to run this rule at.
+
+        :default: - Whichever day of the week that ``day`` falls on
+        '''
+        result = self._values.get("week_day")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def year(self) -> typing.Optional[builtins.str]:
+        '''The year to run this rule at.
+
+        :default: - Every year
+        '''
+        result = self._values.get("year")
+        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 "CronOptions(%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=[],
@@ -23271,15 +23526,683 @@ class EventBridgePutEventsProps(_TaskStateBaseProps_3a62b6d0):
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
 
     @builtins.property
-    def entries(self) -> typing.List[EventBridgePutEventsEntry]:
-        '''The entries that will be sent.
+    def entries(self) -> typing.List[EventBridgePutEventsEntry]:
+        '''The entries that will be sent.
+
+        Minimum number of entries is 1 and maximum is 10,
+        unless `PutEvents API limit <https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEvents.html#API_PutEvents_RequestSyntax>`_ has changed.
+        '''
+        result = self._values.get("entries")
+        assert result is not None, "Required property 'entries' is missing"
+        return typing.cast(typing.List[EventBridgePutEventsEntry], 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 "EventBridgePutEventsProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+class EventBridgeSchedulerCreateScheduleTask(
+    _TaskStateBase_b5c0a816,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.EventBridgeSchedulerCreateScheduleTask",
+):
+    '''Create a new AWS EventBridge Scheduler schedule.
+
+    :see: https://docs.aws.amazon.com/scheduler/latest/APIReference/API_CreateSchedule.html
+    :exampleMetadata: infused
+
+    Example::
+
+        import aws_cdk.aws_scheduler as scheduler
+        import aws_cdk.aws_kms as kms
+        
+        # key: kms.Key
+        # schedule_group: scheduler.CfnScheduleGroup
+        # target_queue: sqs.Queue
+        # dead_letter_queue: sqs.Queue
+        
+        
+        scheduler_role = iam.Role(self, "SchedulerRole",
+            assumed_by=iam.ServicePrincipal("scheduler.amazonaws.com")
+        )
+        # To send the message to the queue
+        # This policy changes depending on the type of target.
+        scheduler_role.add_to_principal_policy(iam.PolicyStatement(
+            actions=["sqs:SendMessage"],
+            resources=[target_queue.queue_arn]
+        ))
+        
+        create_schedule_task1 = tasks.EventBridgeSchedulerCreateScheduleTask(self, "createSchedule",
+            schedule_name="TestSchedule",
+            action_after_completion=tasks.ActionAfterCompletion.NONE,
+            client_token="testToken",
+            description="TestDescription",
+            start_date=Date(),
+            end_date=Date(Date().get_time() + 1000 * 60 * 60),
+            flexible_time_window=Duration.minutes(5),
+            group_name=schedule_group.ref,
+            kms_key=key,
+            schedule=tasks.Schedule.rate(Duration.minutes(5)),
+            timezone="UTC",
+            enabled=True,
+            target=tasks.EventBridgeSchedulerTarget(
+                arn=target_queue.queue_arn,
+                role=scheduler_role,
+                retry_policy=tasks.RetryPolicy(
+                    maximum_retry_attempts=2,
+                    maximum_event_age=Duration.minutes(5)
+                ),
+                dead_letter_queue=dead_letter_queue
+            )
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        schedule: "Schedule",
+        schedule_name: builtins.str,
+        target: "EventBridgeSchedulerTarget",
+        action_after_completion: typing.Optional[ActionAfterCompletion] = None,
+        client_token: typing.Optional[builtins.str] = None,
+        description: typing.Optional[builtins.str] = None,
+        enabled: typing.Optional[builtins.bool] = None,
+        end_date: typing.Optional[datetime.datetime] = None,
+        flexible_time_window: typing.Optional[_Duration_4839e8c3] = None,
+        group_name: typing.Optional[builtins.str] = None,
+        kms_key: typing.Optional[_IKey_5f11635f] = None,
+        start_date: typing.Optional[datetime.datetime] = None,
+        timezone: typing.Optional[builtins.str] = None,
+        comment: typing.Optional[builtins.str] = None,
+        credentials: typing.Optional[typing.Union[_Credentials_2cd64c6b, typing.Dict[builtins.str, typing.Any]]] = None,
+        heartbeat: typing.Optional[_Duration_4839e8c3] = None,
+        heartbeat_timeout: typing.Optional[_Timeout_d7c10551] = None,
+        input_path: typing.Optional[builtins.str] = None,
+        integration_pattern: typing.Optional[_IntegrationPattern_949291bc] = None,
+        output_path: typing.Optional[builtins.str] = None,
+        result_path: typing.Optional[builtins.str] = None,
+        result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+        state_name: typing.Optional[builtins.str] = None,
+        task_timeout: typing.Optional[_Timeout_d7c10551] = None,
+        timeout: typing.Optional[_Duration_4839e8c3] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param id: Descriptive identifier for this chainable.
+        :param schedule: The schedule that defines when the schedule will trigger.
+        :param schedule_name: Schedule name.
+        :param target: The schedule's target.
+        :param action_after_completion: Specifies the action that EventBridge Scheduler applies to the schedule after the schedule completes invoking the target. Default: ActionAfterCompletion.NONE
+        :param client_token: Unique, case-sensitive identifier to ensure the idempotency of the request. Default: - Automatically generated
+        :param description: The description for the schedule. Default: - No description
+        :param enabled: Specifies whether the schedule is enabled or disabled. Default: true
+        :param end_date: The date, in UTC, before which the schedule can invoke its target. Depending on the schedule's recurrence expression, invocations might stop on, or before, the EndDate you specify. EventBridge Scheduler ignores EndDate for one-time schedules. Default: - No end date
+        :param flexible_time_window: The maximum time window during which a schedule can be invoked. Minimum value is 1 minute. Maximum value is 1440 minutes (1 day). Default: - Flexible time window is not enabled.
+        :param group_name: The name of the schedule group to associate with this schedule. Default: - The default schedule group is used.
+        :param kms_key: The customer managed KMS key that EventBridge Scheduler will use to encrypt and decrypt payload. Default: - Use automatically generated KMS key
+        :param start_date: The date, in UTC, after which the schedule can begin invoking its target. Depending on the schedule's recurrence expression, invocations might occur on, or after, the StartDate you specify. EventBridge Scheduler ignores StartDate for one-time schedules. Default: - No start date
+        :param timezone: The timezone in which the scheduling expression is evaluated. Default: - UTC
+        :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__d4cb892d1936cdb9cedbfb77092003022fa30c87f9067911038653144e7000e1)
+            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 = EventBridgeSchedulerCreateScheduleTaskProps(
+            schedule=schedule,
+            schedule_name=schedule_name,
+            target=target,
+            action_after_completion=action_after_completion,
+            client_token=client_token,
+            description=description,
+            enabled=enabled,
+            end_date=end_date,
+            flexible_time_window=flexible_time_window,
+            group_name=group_name,
+            kms_key=kms_key,
+            start_date=start_date,
+            timezone=timezone,
+            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.EventBridgeSchedulerCreateScheduleTaskProps",
+    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",
+        "schedule": "schedule",
+        "schedule_name": "scheduleName",
+        "target": "target",
+        "action_after_completion": "actionAfterCompletion",
+        "client_token": "clientToken",
+        "description": "description",
+        "enabled": "enabled",
+        "end_date": "endDate",
+        "flexible_time_window": "flexibleTimeWindow",
+        "group_name": "groupName",
+        "kms_key": "kmsKey",
+        "start_date": "startDate",
+        "timezone": "timezone",
+    },
+)
+class EventBridgeSchedulerCreateScheduleTaskProps(_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,
+        schedule: "Schedule",
+        schedule_name: builtins.str,
+        target: "EventBridgeSchedulerTarget",
+        action_after_completion: typing.Optional[ActionAfterCompletion] = None,
+        client_token: typing.Optional[builtins.str] = None,
+        description: typing.Optional[builtins.str] = None,
+        enabled: typing.Optional[builtins.bool] = None,
+        end_date: typing.Optional[datetime.datetime] = None,
+        flexible_time_window: typing.Optional[_Duration_4839e8c3] = None,
+        group_name: typing.Optional[builtins.str] = None,
+        kms_key: typing.Optional[_IKey_5f11635f] = None,
+        start_date: typing.Optional[datetime.datetime] = None,
+        timezone: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''Properties for creating an AWS EventBridge Scheduler schedule.
+
+        :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 schedule: The schedule that defines when the schedule will trigger.
+        :param schedule_name: Schedule name.
+        :param target: The schedule's target.
+        :param action_after_completion: Specifies the action that EventBridge Scheduler applies to the schedule after the schedule completes invoking the target. Default: ActionAfterCompletion.NONE
+        :param client_token: Unique, case-sensitive identifier to ensure the idempotency of the request. Default: - Automatically generated
+        :param description: The description for the schedule. Default: - No description
+        :param enabled: Specifies whether the schedule is enabled or disabled. Default: true
+        :param end_date: The date, in UTC, before which the schedule can invoke its target. Depending on the schedule's recurrence expression, invocations might stop on, or before, the EndDate you specify. EventBridge Scheduler ignores EndDate for one-time schedules. Default: - No end date
+        :param flexible_time_window: The maximum time window during which a schedule can be invoked. Minimum value is 1 minute. Maximum value is 1440 minutes (1 day). Default: - Flexible time window is not enabled.
+        :param group_name: The name of the schedule group to associate with this schedule. Default: - The default schedule group is used.
+        :param kms_key: The customer managed KMS key that EventBridge Scheduler will use to encrypt and decrypt payload. Default: - Use automatically generated KMS key
+        :param start_date: The date, in UTC, after which the schedule can begin invoking its target. Depending on the schedule's recurrence expression, invocations might occur on, or after, the StartDate you specify. EventBridge Scheduler ignores StartDate for one-time schedules. Default: - No start date
+        :param timezone: The timezone in which the scheduling expression is evaluated. Default: - UTC
+
+        :exampleMetadata: infused
+
+        Example::
+
+            import aws_cdk.aws_scheduler as scheduler
+            import aws_cdk.aws_kms as kms
+            
+            # key: kms.Key
+            # schedule_group: scheduler.CfnScheduleGroup
+            # target_queue: sqs.Queue
+            # dead_letter_queue: sqs.Queue
+            
+            
+            scheduler_role = iam.Role(self, "SchedulerRole",
+                assumed_by=iam.ServicePrincipal("scheduler.amazonaws.com")
+            )
+            # To send the message to the queue
+            # This policy changes depending on the type of target.
+            scheduler_role.add_to_principal_policy(iam.PolicyStatement(
+                actions=["sqs:SendMessage"],
+                resources=[target_queue.queue_arn]
+            ))
+            
+            create_schedule_task1 = tasks.EventBridgeSchedulerCreateScheduleTask(self, "createSchedule",
+                schedule_name="TestSchedule",
+                action_after_completion=tasks.ActionAfterCompletion.NONE,
+                client_token="testToken",
+                description="TestDescription",
+                start_date=Date(),
+                end_date=Date(Date().get_time() + 1000 * 60 * 60),
+                flexible_time_window=Duration.minutes(5),
+                group_name=schedule_group.ref,
+                kms_key=key,
+                schedule=tasks.Schedule.rate(Duration.minutes(5)),
+                timezone="UTC",
+                enabled=True,
+                target=tasks.EventBridgeSchedulerTarget(
+                    arn=target_queue.queue_arn,
+                    role=scheduler_role,
+                    retry_policy=tasks.RetryPolicy(
+                        maximum_retry_attempts=2,
+                        maximum_event_age=Duration.minutes(5)
+                    ),
+                    dead_letter_queue=dead_letter_queue
+                )
+            )
+        '''
+        if isinstance(credentials, dict):
+            credentials = _Credentials_2cd64c6b(**credentials)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__2ca0e1f6c70f9052670025ee76f1aee1aa07fd94e10b6fa83ff1c51c8304e804)
+            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 schedule", value=schedule, expected_type=type_hints["schedule"])
+            check_type(argname="argument schedule_name", value=schedule_name, expected_type=type_hints["schedule_name"])
+            check_type(argname="argument target", value=target, expected_type=type_hints["target"])
+            check_type(argname="argument action_after_completion", value=action_after_completion, expected_type=type_hints["action_after_completion"])
+            check_type(argname="argument client_token", value=client_token, expected_type=type_hints["client_token"])
+            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
+            check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
+            check_type(argname="argument end_date", value=end_date, expected_type=type_hints["end_date"])
+            check_type(argname="argument flexible_time_window", value=flexible_time_window, expected_type=type_hints["flexible_time_window"])
+            check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
+            check_type(argname="argument kms_key", value=kms_key, expected_type=type_hints["kms_key"])
+            check_type(argname="argument start_date", value=start_date, expected_type=type_hints["start_date"])
+            check_type(argname="argument timezone", value=timezone, expected_type=type_hints["timezone"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "schedule": schedule,
+            "schedule_name": schedule_name,
+            "target": target,
+        }
+        if comment is not None:
+            self._values["comment"] = comment
+        if credentials is not None:
+            self._values["credentials"] = credentials
+        if heartbeat is not None:
+            self._values["heartbeat"] = heartbeat
+        if heartbeat_timeout is not None:
+            self._values["heartbeat_timeout"] = heartbeat_timeout
+        if input_path is not None:
+            self._values["input_path"] = input_path
+        if integration_pattern is not None:
+            self._values["integration_pattern"] = integration_pattern
+        if output_path is not None:
+            self._values["output_path"] = output_path
+        if result_path is not None:
+            self._values["result_path"] = result_path
+        if result_selector is not None:
+            self._values["result_selector"] = result_selector
+        if state_name is not None:
+            self._values["state_name"] = state_name
+        if task_timeout is not None:
+            self._values["task_timeout"] = task_timeout
+        if timeout is not None:
+            self._values["timeout"] = timeout
+        if action_after_completion is not None:
+            self._values["action_after_completion"] = action_after_completion
+        if client_token is not None:
+            self._values["client_token"] = client_token
+        if description is not None:
+            self._values["description"] = description
+        if enabled is not None:
+            self._values["enabled"] = enabled
+        if end_date is not None:
+            self._values["end_date"] = end_date
+        if flexible_time_window is not None:
+            self._values["flexible_time_window"] = flexible_time_window
+        if group_name is not None:
+            self._values["group_name"] = group_name
+        if kms_key is not None:
+            self._values["kms_key"] = kms_key
+        if start_date is not None:
+            self._values["start_date"] = start_date
+        if timezone is not None:
+            self._values["timezone"] = timezone
+
+    @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 schedule(self) -> "Schedule":
+        '''The schedule that defines when the schedule will trigger.
 
-        Minimum number of entries is 1 and maximum is 10,
-        unless `PutEvents API limit <https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEvents.html#API_PutEvents_RequestSyntax>`_ has changed.
+        :see: https://docs.aws.amazon.com/scheduler/latest/UserGuide/schedule-types.html
         '''
-        result = self._values.get("entries")
-        assert result is not None, "Required property 'entries' is missing"
-        return typing.cast(typing.List[EventBridgePutEventsEntry], result)
+        result = self._values.get("schedule")
+        assert result is not None, "Required property 'schedule' is missing"
+        return typing.cast("Schedule", result)
+
+    @builtins.property
+    def schedule_name(self) -> builtins.str:
+        '''Schedule name.'''
+        result = self._values.get("schedule_name")
+        assert result is not None, "Required property 'schedule_name' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def target(self) -> "EventBridgeSchedulerTarget":
+        '''The schedule's target.'''
+        result = self._values.get("target")
+        assert result is not None, "Required property 'target' is missing"
+        return typing.cast("EventBridgeSchedulerTarget", result)
+
+    @builtins.property
+    def action_after_completion(self) -> typing.Optional[ActionAfterCompletion]:
+        '''Specifies the action that EventBridge Scheduler applies to the schedule after the schedule completes invoking the target.
+
+        :default: ActionAfterCompletion.NONE
+        '''
+        result = self._values.get("action_after_completion")
+        return typing.cast(typing.Optional[ActionAfterCompletion], result)
+
+    @builtins.property
+    def client_token(self) -> typing.Optional[builtins.str]:
+        '''Unique, case-sensitive identifier to ensure the idempotency of the request.
+
+        :default: - Automatically generated
+        '''
+        result = self._values.get("client_token")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def description(self) -> typing.Optional[builtins.str]:
+        '''The description for the schedule.
+
+        :default: - No description
+        '''
+        result = self._values.get("description")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def enabled(self) -> typing.Optional[builtins.bool]:
+        '''Specifies whether the schedule is enabled or disabled.
+
+        :default: true
+        '''
+        result = self._values.get("enabled")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def end_date(self) -> typing.Optional[datetime.datetime]:
+        '''The date, in UTC, before which the schedule can invoke its target.
+
+        Depending on the schedule's recurrence expression, invocations might stop on, or before, the EndDate you specify.
+        EventBridge Scheduler ignores EndDate for one-time schedules.
+
+        :default: - No end date
+        '''
+        result = self._values.get("end_date")
+        return typing.cast(typing.Optional[datetime.datetime], result)
+
+    @builtins.property
+    def flexible_time_window(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''The maximum time window during which a schedule can be invoked.
+
+        Minimum value is 1 minute.
+        Maximum value is 1440 minutes (1 day).
+
+        :default: - Flexible time window is not enabled.
+        '''
+        result = self._values.get("flexible_time_window")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
+    @builtins.property
+    def group_name(self) -> typing.Optional[builtins.str]:
+        '''The name of the schedule group to associate with this schedule.
+
+        :default: - The default schedule group is used.
+        '''
+        result = self._values.get("group_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def kms_key(self) -> typing.Optional[_IKey_5f11635f]:
+        '''The customer managed KMS key that EventBridge Scheduler will use to encrypt and decrypt payload.
+
+        :default: - Use automatically generated KMS key
+
+        :see: https://docs.aws.amazon.com/scheduler/latest/UserGuide/encryption-rest.html
+        '''
+        result = self._values.get("kms_key")
+        return typing.cast(typing.Optional[_IKey_5f11635f], result)
+
+    @builtins.property
+    def start_date(self) -> typing.Optional[datetime.datetime]:
+        '''The date, in UTC, after which the schedule can begin invoking its target.
+
+        Depending on the schedule's recurrence expression, invocations might occur on, or after, the StartDate you specify.
+        EventBridge Scheduler ignores StartDate for one-time schedules.
+
+        :default: - No start date
+        '''
+        result = self._values.get("start_date")
+        return typing.cast(typing.Optional[datetime.datetime], result)
+
+    @builtins.property
+    def timezone(self) -> typing.Optional[builtins.str]:
+        '''The timezone in which the scheduling expression is evaluated.
+
+        :default: - UTC
+        '''
+        result = self._values.get("timezone")
+        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
@@ -23288,7 +24211,311 @@ class EventBridgePutEventsProps(_TaskStateBaseProps_3a62b6d0):
         return not (rhs == self)
 
     def __repr__(self) -> str:
-        return "EventBridgePutEventsProps(%s)" % ", ".join(
+        return "EventBridgeSchedulerCreateScheduleTaskProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+class EventBridgeSchedulerTarget(
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.EventBridgeSchedulerTarget",
+):
+    '''The target that EventBridge Scheduler will invoke.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        import aws_cdk.aws_scheduler as scheduler
+        import aws_cdk.aws_kms as kms
+        
+        # key: kms.Key
+        # schedule_group: scheduler.CfnScheduleGroup
+        # target_queue: sqs.Queue
+        # dead_letter_queue: sqs.Queue
+        
+        
+        scheduler_role = iam.Role(self, "SchedulerRole",
+            assumed_by=iam.ServicePrincipal("scheduler.amazonaws.com")
+        )
+        # To send the message to the queue
+        # This policy changes depending on the type of target.
+        scheduler_role.add_to_principal_policy(iam.PolicyStatement(
+            actions=["sqs:SendMessage"],
+            resources=[target_queue.queue_arn]
+        ))
+        
+        create_schedule_task1 = tasks.EventBridgeSchedulerCreateScheduleTask(self, "createSchedule",
+            schedule_name="TestSchedule",
+            action_after_completion=tasks.ActionAfterCompletion.NONE,
+            client_token="testToken",
+            description="TestDescription",
+            start_date=Date(),
+            end_date=Date(Date().get_time() + 1000 * 60 * 60),
+            flexible_time_window=Duration.minutes(5),
+            group_name=schedule_group.ref,
+            kms_key=key,
+            schedule=tasks.Schedule.rate(Duration.minutes(5)),
+            timezone="UTC",
+            enabled=True,
+            target=tasks.EventBridgeSchedulerTarget(
+                arn=target_queue.queue_arn,
+                role=scheduler_role,
+                retry_policy=tasks.RetryPolicy(
+                    maximum_retry_attempts=2,
+                    maximum_event_age=Duration.minutes(5)
+                ),
+                dead_letter_queue=dead_letter_queue
+            )
+        )
+    '''
+
+    def __init__(
+        self,
+        *,
+        arn: builtins.str,
+        role: _IRole_235f5d8e,
+        dead_letter_queue: typing.Optional[_IQueue_7ed6f679] = None,
+        input: typing.Optional[builtins.str] = None,
+        retry_policy: typing.Optional[typing.Union["RetryPolicy", typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> None:
+        '''
+        :param arn: The Amazon Resource Name (ARN) of the target.
+        :param role: The IAM role that EventBridge Scheduler will use for this target when the schedule is invoked.
+        :param dead_letter_queue: Dead letter queue for failed events. Default: - No dead letter queue
+        :param input: The input to the target. Default: - EventBridge Scheduler delivers a default notification to the target
+        :param retry_policy: The retry policy settings. Default: - Do not retry
+        '''
+        props = EventBridgeSchedulerTargetProps(
+            arn=arn,
+            role=role,
+            dead_letter_queue=dead_letter_queue,
+            input=input,
+            retry_policy=retry_policy,
+        )
+
+        jsii.create(self.__class__, self, [props])
+
+    @jsii.member(jsii_name="renderTargetObject")
+    def render_target_object(self) -> typing.Any:
+        '''return the target object for the EventBridge Scheduler.'''
+        return typing.cast(typing.Any, jsii.invoke(self, "renderTargetObject", []))
+
+    @builtins.property
+    @jsii.member(jsii_name="arn")
+    def arn(self) -> builtins.str:
+        '''The Amazon Resource Name (ARN) of the target.'''
+        return typing.cast(builtins.str, jsii.get(self, "arn"))
+
+    @arn.setter
+    def arn(self, value: builtins.str) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__08399721dc3339ea162c3eb58b966c2135f7b985764627b33d6165699f2fe7a9)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "arn", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="role")
+    def role(self) -> _IRole_235f5d8e:
+        '''The IAM role that EventBridge Scheduler will use for this target when the schedule is invoked.'''
+        return typing.cast(_IRole_235f5d8e, jsii.get(self, "role"))
+
+    @role.setter
+    def role(self, value: _IRole_235f5d8e) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__279822f7cb0eddabb17ddd4de4d374b62ac9aec5de2b4f5127c638cfacf8183d)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "role", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="deadLetterQueue")
+    def dead_letter_queue(self) -> typing.Optional[_IQueue_7ed6f679]:
+        '''Dead letter queue for failed events.'''
+        return typing.cast(typing.Optional[_IQueue_7ed6f679], jsii.get(self, "deadLetterQueue"))
+
+    @dead_letter_queue.setter
+    def dead_letter_queue(self, value: typing.Optional[_IQueue_7ed6f679]) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__2740fb9a1bb904a28e993d62d6f1a5fc12667d92b6515d4d2433e2b8e8903e3e)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "deadLetterQueue", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="input")
+    def input(self) -> typing.Optional[builtins.str]:
+        '''The input to the target.'''
+        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "input"))
+
+    @input.setter
+    def input(self, value: typing.Optional[builtins.str]) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__47114e604ac28a24d6cd14b23a4c054ce75fcb98cde7d3563faee1c1c77ae510)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "input", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="retryPolicy")
+    def retry_policy(self) -> typing.Optional["RetryPolicy"]:
+        '''The retry policy settings.'''
+        return typing.cast(typing.Optional["RetryPolicy"], jsii.get(self, "retryPolicy"))
+
+    @retry_policy.setter
+    def retry_policy(self, value: typing.Optional["RetryPolicy"]) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__132145ba0a6d11089eaa41ce28ee78b1e93e936cf0e454686be50ef9ffcd6629)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "retryPolicy", value) # pyright: ignore[reportArgumentType]
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.EventBridgeSchedulerTargetProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "arn": "arn",
+        "role": "role",
+        "dead_letter_queue": "deadLetterQueue",
+        "input": "input",
+        "retry_policy": "retryPolicy",
+    },
+)
+class EventBridgeSchedulerTargetProps:
+    def __init__(
+        self,
+        *,
+        arn: builtins.str,
+        role: _IRole_235f5d8e,
+        dead_letter_queue: typing.Optional[_IQueue_7ed6f679] = None,
+        input: typing.Optional[builtins.str] = None,
+        retry_policy: typing.Optional[typing.Union["RetryPolicy", typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> None:
+        '''Properties for ``EventBridgeSchedulerTarget``.
+
+        :param arn: The Amazon Resource Name (ARN) of the target.
+        :param role: The IAM role that EventBridge Scheduler will use for this target when the schedule is invoked.
+        :param dead_letter_queue: Dead letter queue for failed events. Default: - No dead letter queue
+        :param input: The input to the target. Default: - EventBridge Scheduler delivers a default notification to the target
+        :param retry_policy: The retry policy settings. Default: - Do not retry
+
+        :see: https://docs.aws.amazon.com/scheduler/latest/APIReference/API_Target.html#API_Target_Contents
+        :exampleMetadata: infused
+
+        Example::
+
+            import aws_cdk.aws_scheduler as scheduler
+            import aws_cdk.aws_kms as kms
+            
+            # key: kms.Key
+            # schedule_group: scheduler.CfnScheduleGroup
+            # target_queue: sqs.Queue
+            # dead_letter_queue: sqs.Queue
+            
+            
+            scheduler_role = iam.Role(self, "SchedulerRole",
+                assumed_by=iam.ServicePrincipal("scheduler.amazonaws.com")
+            )
+            # To send the message to the queue
+            # This policy changes depending on the type of target.
+            scheduler_role.add_to_principal_policy(iam.PolicyStatement(
+                actions=["sqs:SendMessage"],
+                resources=[target_queue.queue_arn]
+            ))
+            
+            create_schedule_task1 = tasks.EventBridgeSchedulerCreateScheduleTask(self, "createSchedule",
+                schedule_name="TestSchedule",
+                action_after_completion=tasks.ActionAfterCompletion.NONE,
+                client_token="testToken",
+                description="TestDescription",
+                start_date=Date(),
+                end_date=Date(Date().get_time() + 1000 * 60 * 60),
+                flexible_time_window=Duration.minutes(5),
+                group_name=schedule_group.ref,
+                kms_key=key,
+                schedule=tasks.Schedule.rate(Duration.minutes(5)),
+                timezone="UTC",
+                enabled=True,
+                target=tasks.EventBridgeSchedulerTarget(
+                    arn=target_queue.queue_arn,
+                    role=scheduler_role,
+                    retry_policy=tasks.RetryPolicy(
+                        maximum_retry_attempts=2,
+                        maximum_event_age=Duration.minutes(5)
+                    ),
+                    dead_letter_queue=dead_letter_queue
+                )
+            )
+        '''
+        if isinstance(retry_policy, dict):
+            retry_policy = RetryPolicy(**retry_policy)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__83724652ee20223ac0a080d8bf422dd2f7054179bab61153de248e08ef4efb52)
+            check_type(argname="argument arn", value=arn, expected_type=type_hints["arn"])
+            check_type(argname="argument role", value=role, expected_type=type_hints["role"])
+            check_type(argname="argument dead_letter_queue", value=dead_letter_queue, expected_type=type_hints["dead_letter_queue"])
+            check_type(argname="argument input", value=input, expected_type=type_hints["input"])
+            check_type(argname="argument retry_policy", value=retry_policy, expected_type=type_hints["retry_policy"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "arn": arn,
+            "role": role,
+        }
+        if dead_letter_queue is not None:
+            self._values["dead_letter_queue"] = dead_letter_queue
+        if input is not None:
+            self._values["input"] = input
+        if retry_policy is not None:
+            self._values["retry_policy"] = retry_policy
+
+    @builtins.property
+    def arn(self) -> builtins.str:
+        '''The Amazon Resource Name (ARN) of the target.
+
+        :see: https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets.html
+        '''
+        result = self._values.get("arn")
+        assert result is not None, "Required property 'arn' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def role(self) -> _IRole_235f5d8e:
+        '''The IAM role that EventBridge Scheduler will use for this target when the schedule is invoked.'''
+        result = self._values.get("role")
+        assert result is not None, "Required property 'role' is missing"
+        return typing.cast(_IRole_235f5d8e, result)
+
+    @builtins.property
+    def dead_letter_queue(self) -> typing.Optional[_IQueue_7ed6f679]:
+        '''Dead letter queue for failed events.
+
+        :default: - No dead letter queue
+        '''
+        result = self._values.get("dead_letter_queue")
+        return typing.cast(typing.Optional[_IQueue_7ed6f679], result)
+
+    @builtins.property
+    def input(self) -> typing.Optional[builtins.str]:
+        '''The input to the target.
+
+        :default: - EventBridge Scheduler delivers a default notification to the target
+        '''
+        result = self._values.get("input")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def retry_policy(self) -> typing.Optional["RetryPolicy"]:
+        '''The retry policy settings.
+
+        :default: - Do not retry
+        '''
+        result = self._values.get("retry_policy")
+        return typing.cast(typing.Optional["RetryPolicy"], 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 "EventBridgeSchedulerTargetProps(%s)" % ", ".join(
             k + "=" + repr(v) for k, v in self._values.items()
         )
 
@@ -27690,6 +28917,108 @@ class ResultConfiguration:
         )
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.RetryPolicy",
+    jsii_struct_bases=[],
+    name_mapping={
+        "maximum_event_age": "maximumEventAge",
+        "maximum_retry_attempts": "maximumRetryAttempts",
+    },
+)
+class RetryPolicy:
+    def __init__(
+        self,
+        *,
+        maximum_event_age: _Duration_4839e8c3,
+        maximum_retry_attempts: jsii.Number,
+    ) -> None:
+        '''The information about the retry policy settings.
+
+        :param maximum_event_age: The maximum amount of time to continue to make retry attempts.
+        :param maximum_retry_attempts: The maximum number of retry attempts to make before the request fails.
+
+        :exampleMetadata: infused
+
+        Example::
+
+            import aws_cdk.aws_scheduler as scheduler
+            import aws_cdk.aws_kms as kms
+            
+            # key: kms.Key
+            # schedule_group: scheduler.CfnScheduleGroup
+            # target_queue: sqs.Queue
+            # dead_letter_queue: sqs.Queue
+            
+            
+            scheduler_role = iam.Role(self, "SchedulerRole",
+                assumed_by=iam.ServicePrincipal("scheduler.amazonaws.com")
+            )
+            # To send the message to the queue
+            # This policy changes depending on the type of target.
+            scheduler_role.add_to_principal_policy(iam.PolicyStatement(
+                actions=["sqs:SendMessage"],
+                resources=[target_queue.queue_arn]
+            ))
+            
+            create_schedule_task1 = tasks.EventBridgeSchedulerCreateScheduleTask(self, "createSchedule",
+                schedule_name="TestSchedule",
+                action_after_completion=tasks.ActionAfterCompletion.NONE,
+                client_token="testToken",
+                description="TestDescription",
+                start_date=Date(),
+                end_date=Date(Date().get_time() + 1000 * 60 * 60),
+                flexible_time_window=Duration.minutes(5),
+                group_name=schedule_group.ref,
+                kms_key=key,
+                schedule=tasks.Schedule.rate(Duration.minutes(5)),
+                timezone="UTC",
+                enabled=True,
+                target=tasks.EventBridgeSchedulerTarget(
+                    arn=target_queue.queue_arn,
+                    role=scheduler_role,
+                    retry_policy=tasks.RetryPolicy(
+                        maximum_retry_attempts=2,
+                        maximum_event_age=Duration.minutes(5)
+                    ),
+                    dead_letter_queue=dead_letter_queue
+                )
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__98d7f08183c8521e775b42fe55de270346af99ef79758a7f11f3b7f46644a8ed)
+            check_type(argname="argument maximum_event_age", value=maximum_event_age, expected_type=type_hints["maximum_event_age"])
+            check_type(argname="argument maximum_retry_attempts", value=maximum_retry_attempts, expected_type=type_hints["maximum_retry_attempts"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "maximum_event_age": maximum_event_age,
+            "maximum_retry_attempts": maximum_retry_attempts,
+        }
+
+    @builtins.property
+    def maximum_event_age(self) -> _Duration_4839e8c3:
+        '''The maximum amount of time to continue to make retry attempts.'''
+        result = self._values.get("maximum_event_age")
+        assert result is not None, "Required property 'maximum_event_age' is missing"
+        return typing.cast(_Duration_4839e8c3, result)
+
+    @builtins.property
+    def maximum_retry_attempts(self) -> jsii.Number:
+        '''The maximum number of retry attempts to make before the request fails.'''
+        result = self._values.get("maximum_retry_attempts")
+        assert result is not None, "Required property 'maximum_retry_attempts' is missing"
+        return typing.cast(jsii.Number, result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "RetryPolicy(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.enum(jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.S3DataDistributionType")
 class S3DataDistributionType(enum.Enum):
     '''S3 Data Distribution Type.'''
@@ -31141,6 +32470,125 @@ class SageMakerUpdateEndpointProps(_TaskStateBaseProps_3a62b6d0):
         )
 
 
+class Schedule(
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.Schedule",
+):
+    '''Schedule for EventBridge Scheduler.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        import aws_cdk.aws_scheduler as scheduler
+        import aws_cdk.aws_kms as kms
+        
+        # key: kms.Key
+        # schedule_group: scheduler.CfnScheduleGroup
+        # target_queue: sqs.Queue
+        # dead_letter_queue: sqs.Queue
+        
+        
+        scheduler_role = iam.Role(self, "SchedulerRole",
+            assumed_by=iam.ServicePrincipal("scheduler.amazonaws.com")
+        )
+        # To send the message to the queue
+        # This policy changes depending on the type of target.
+        scheduler_role.add_to_principal_policy(iam.PolicyStatement(
+            actions=["sqs:SendMessage"],
+            resources=[target_queue.queue_arn]
+        ))
+        
+        create_schedule_task1 = tasks.EventBridgeSchedulerCreateScheduleTask(self, "createSchedule",
+            schedule_name="TestSchedule",
+            action_after_completion=tasks.ActionAfterCompletion.NONE,
+            client_token="testToken",
+            description="TestDescription",
+            start_date=Date(),
+            end_date=Date(Date().get_time() + 1000 * 60 * 60),
+            flexible_time_window=Duration.minutes(5),
+            group_name=schedule_group.ref,
+            kms_key=key,
+            schedule=tasks.Schedule.rate(Duration.minutes(5)),
+            timezone="UTC",
+            enabled=True,
+            target=tasks.EventBridgeSchedulerTarget(
+                arn=target_queue.queue_arn,
+                role=scheduler_role,
+                retry_policy=tasks.RetryPolicy(
+                    maximum_retry_attempts=2,
+                    maximum_event_age=Duration.minutes(5)
+                ),
+                dead_letter_queue=dead_letter_queue
+            )
+        )
+    '''
+
+    @jsii.member(jsii_name="cron")
+    @builtins.classmethod
+    def cron(
+        cls,
+        *,
+        day: typing.Optional[builtins.str] = None,
+        hour: typing.Optional[builtins.str] = None,
+        minute: typing.Optional[builtins.str] = None,
+        month: typing.Optional[builtins.str] = None,
+        week_day: typing.Optional[builtins.str] = None,
+        year: typing.Optional[builtins.str] = None,
+    ) -> "Schedule":
+        '''Create a cron-based schedule from a set of cron fields.
+
+        :param day: The day of the month to run this rule at. Default: - Every day of the month
+        :param hour: The hour to run this rule at. Default: - Every hour
+        :param minute: The minute to run this rule at. Default: - Every minute
+        :param month: The month to run this rule at. Default: - Every month
+        :param week_day: The day of the week to run this rule at. Default: - Whichever day of the week that ``day`` falls on
+        :param year: The year to run this rule at. Default: - Every year
+        '''
+        options = CronOptions(
+            day=day,
+            hour=hour,
+            minute=minute,
+            month=month,
+            week_day=week_day,
+            year=year,
+        )
+
+        return typing.cast("Schedule", jsii.sinvoke(cls, "cron", [options]))
+
+    @jsii.member(jsii_name="oneTime")
+    @builtins.classmethod
+    def one_time(cls, time: datetime.datetime) -> "Schedule":
+        '''Construct a one-time schedule from a Date.
+
+        :param time: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__5d9c36e51b3ea0cf38a1d8aa35ba2b2f487b3e663a742ee4c205897aaac84602)
+            check_type(argname="argument time", value=time, expected_type=type_hints["time"])
+        return typing.cast("Schedule", jsii.sinvoke(cls, "oneTime", [time]))
+
+    @jsii.member(jsii_name="rate")
+    @builtins.classmethod
+    def rate(cls, duration: _Duration_4839e8c3) -> "Schedule":
+        '''Construct a rate-based schedule from an interval.
+
+        The minimum interval is 1 minute.
+
+        :param duration: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__ee7a5ee61b7c1e1eb0d0eb44a69b770e429c08e40f6e65c26a812408764e2260)
+            check_type(argname="argument duration", value=duration, expected_type=type_hints["duration"])
+        return typing.cast("Schedule", jsii.sinvoke(cls, "rate", [duration]))
+
+    @builtins.property
+    @jsii.member(jsii_name="expressionString")
+    def expression_string(self) -> builtins.str:
+        '''The Schedule expression.'''
+        return typing.cast(builtins.str, jsii.get(self, "expressionString"))
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_stepfunctions_tasks.ShuffleConfig",
     jsii_struct_bases=[],
@@ -34364,6 +35812,7 @@ class EcsFargateLaunchTarget(
 __all__ = [
     "AcceleratorClass",
     "AcceleratorType",
+    "ActionAfterCompletion",
     "ActionOnFailure",
     "AlgorithmSpecification",
     "ApplicationConfiguration",
@@ -34408,6 +35857,7 @@ __all__ = [
     "ContainerDefinitionOptions",
     "ContainerOverride",
     "ContainerOverrides",
+    "CronOptions",
     "DataSource",
     "DockerImage",
     "DockerImageConfig",
@@ -34461,6 +35911,10 @@ __all__ = [
     "EventBridgePutEvents",
     "EventBridgePutEventsEntry",
     "EventBridgePutEventsProps",
+    "EventBridgeSchedulerCreateScheduleTask",
+    "EventBridgeSchedulerCreateScheduleTaskProps",
+    "EventBridgeSchedulerTarget",
+    "EventBridgeSchedulerTargetProps",
     "ExecutionClass",
     "GlueDataBrewStartJobRun",
     "GlueDataBrewStartJobRunProps",
@@ -34498,6 +35952,7 @@ __all__ = [
     "ReleaseLabel",
     "ResourceConfig",
     "ResultConfiguration",
+    "RetryPolicy",
     "S3DataDistributionType",
     "S3DataSource",
     "S3DataType",
@@ -34516,6 +35971,7 @@ __all__ = [
     "SageMakerCreateTransformJobProps",
     "SageMakerUpdateEndpoint",
     "SageMakerUpdateEndpointProps",
+    "Schedule",
     "ShuffleConfig",
     "SnsPublish",
     "SnsPublishProps",
@@ -35299,6 +36755,18 @@ def _typecheckingstub__01041943486aae0759ebb5eb0da770a79ece9051da7b1da79c5ca4956
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__3ded07e1f80001916cedf33047f0de79b459fade9caa718d154ce12553ccfd4b(
+    *,
+    day: typing.Optional[builtins.str] = None,
+    hour: typing.Optional[builtins.str] = None,
+    minute: typing.Optional[builtins.str] = None,
+    month: typing.Optional[builtins.str] = None,
+    week_day: typing.Optional[builtins.str] = None,
+    year: 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]],
@@ -36677,6 +38145,111 @@ def _typecheckingstub__3d1533e2221776c3bad646394bc560a4c2723f94942ecd3f4dacdb6c7
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__d4cb892d1936cdb9cedbfb77092003022fa30c87f9067911038653144e7000e1(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    schedule: Schedule,
+    schedule_name: builtins.str,
+    target: EventBridgeSchedulerTarget,
+    action_after_completion: typing.Optional[ActionAfterCompletion] = None,
+    client_token: typing.Optional[builtins.str] = None,
+    description: typing.Optional[builtins.str] = None,
+    enabled: typing.Optional[builtins.bool] = None,
+    end_date: typing.Optional[datetime.datetime] = None,
+    flexible_time_window: typing.Optional[_Duration_4839e8c3] = None,
+    group_name: typing.Optional[builtins.str] = None,
+    kms_key: typing.Optional[_IKey_5f11635f] = None,
+    start_date: typing.Optional[datetime.datetime] = None,
+    timezone: typing.Optional[builtins.str] = None,
+    comment: typing.Optional[builtins.str] = None,
+    credentials: typing.Optional[typing.Union[_Credentials_2cd64c6b, typing.Dict[builtins.str, typing.Any]]] = None,
+    heartbeat: typing.Optional[_Duration_4839e8c3] = None,
+    heartbeat_timeout: typing.Optional[_Timeout_d7c10551] = None,
+    input_path: typing.Optional[builtins.str] = None,
+    integration_pattern: typing.Optional[_IntegrationPattern_949291bc] = None,
+    output_path: typing.Optional[builtins.str] = None,
+    result_path: typing.Optional[builtins.str] = None,
+    result_selector: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+    state_name: typing.Optional[builtins.str] = None,
+    task_timeout: typing.Optional[_Timeout_d7c10551] = None,
+    timeout: typing.Optional[_Duration_4839e8c3] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__2ca0e1f6c70f9052670025ee76f1aee1aa07fd94e10b6fa83ff1c51c8304e804(
+    *,
+    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,
+    schedule: Schedule,
+    schedule_name: builtins.str,
+    target: EventBridgeSchedulerTarget,
+    action_after_completion: typing.Optional[ActionAfterCompletion] = None,
+    client_token: typing.Optional[builtins.str] = None,
+    description: typing.Optional[builtins.str] = None,
+    enabled: typing.Optional[builtins.bool] = None,
+    end_date: typing.Optional[datetime.datetime] = None,
+    flexible_time_window: typing.Optional[_Duration_4839e8c3] = None,
+    group_name: typing.Optional[builtins.str] = None,
+    kms_key: typing.Optional[_IKey_5f11635f] = None,
+    start_date: typing.Optional[datetime.datetime] = None,
+    timezone: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__08399721dc3339ea162c3eb58b966c2135f7b985764627b33d6165699f2fe7a9(
+    value: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__279822f7cb0eddabb17ddd4de4d374b62ac9aec5de2b4f5127c638cfacf8183d(
+    value: _IRole_235f5d8e,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__2740fb9a1bb904a28e993d62d6f1a5fc12667d92b6515d4d2433e2b8e8903e3e(
+    value: typing.Optional[_IQueue_7ed6f679],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__47114e604ac28a24d6cd14b23a4c054ce75fcb98cde7d3563faee1c1c77ae510(
+    value: typing.Optional[builtins.str],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__132145ba0a6d11089eaa41ce28ee78b1e93e936cf0e454686be50ef9ffcd6629(
+    value: typing.Optional[RetryPolicy],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__83724652ee20223ac0a080d8bf422dd2f7054179bab61153de248e08ef4efb52(
+    *,
+    arn: builtins.str,
+    role: _IRole_235f5d8e,
+    dead_letter_queue: typing.Optional[_IQueue_7ed6f679] = None,
+    input: typing.Optional[builtins.str] = None,
+    retry_policy: typing.Optional[typing.Union[RetryPolicy, typing.Dict[builtins.str, typing.Any]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__cb07757b4483ab674eb60feab8180666aaf3693f5b2c5fc2b5f17e759f97ba8d(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
@@ -37091,6 +38664,14 @@ def _typecheckingstub__33c555cfffa7974fe2e6e47bc31ab2d676beaae1a0049f46abb78a457
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__98d7f08183c8521e775b42fe55de270346af99ef79758a7f11f3b7f46644a8ed(
+    *,
+    maximum_event_age: _Duration_4839e8c3,
+    maximum_retry_attempts: jsii.Number,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__b838b12481cb765d7b3deab25659b461e3b016333b3e6eee25210622bbfb9c08(
     *,
     s3_location: S3Location,
@@ -37460,6 +39041,18 @@ def _typecheckingstub__d96c2c0df56e3dc1707e4ba9fa8a1542b52a2238b392b5de5c6a4cfd8
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__5d9c36e51b3ea0cf38a1d8aa35ba2b2f487b3e663a742ee4c205897aaac84602(
+    time: datetime.datetime,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__ee7a5ee61b7c1e1eb0d0eb44a69b770e429c08e40f6e65c26a812408764e2260(
+    duration: _Duration_4839e8c3,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__faecfc8e3e10593c0b9f5870adc72dfc618190f143d051af9133af1842024ed2(
     *,
     seed: jsii.Number,