'''
# AWS DataOps Development Kit (DDK)

![Actions Status](https://github.com/awslabs/aws-ddk/actions/workflows/bandit.yml/badge.svg)
![Actions Status](https://github.com/awslabs/aws-ddk/actions/workflows/cfn-nag.yml/badge.svg)
![Actions Status](https://github.com/awslabs/aws-ddk/actions/workflows/cli-tests.yml/badge.svg)
![Actions Status](https://github.com/awslabs/aws-ddk/actions/workflows/core-tests.yml/badge.svg)

The AWS DataOps Development Kit is an open source development framework for customers that build data workflows and modern data architecture on AWS.

Based on the [AWS CDK](https://github.com/aws/aws-cdk), it offers high-level abstractions allowing you to build pipelines that manage data flows on AWS, driven by DevOps best practices.  The framework is extensible, you can add abstractions for your own data processing infrastructure or replace our best practices with your own standards. It's easy to share templates, so everyone in your organisation can concentrate on the business logic of dealing with their data, rather than boilerplate logic.

---


The **DDK Core** is a library of CDK constructs that you can use to build data workflows and modern data architecture on AWS, following our best practice. The DDK Core is modular and extensible, if our best practice doesn't work for you, then you can update and share your own version with the rest of your organisation by leveraging a private **AWS Code Artifact** repository.

You can compose constructs from the DDK Core into a **DDK App**.  Your DDK App can also add contain constructs from the CDK Framework or the [AWS Construct Library](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-construct-library.html).

You can use the **DDK CLI** to manage your DDK App.  You can use it to create a new app from a template, or deploy your DDK app to AWS.

## Overview

For a detailed walk-through, check out our [Workshop](https://catalog.us-east-1.prod.workshops.aws/workshops/3644b48b-1d7c-43ef-a353-6edcd96385af/en-US) or
take a look at [examples](https://github.com/aws-samples/aws-ddk-examples).

### Build Data Pipelines

One of the core features of DDK is ability to create Data Pipelines. A DDK [DataPipeline](https://awslabs.github.io/aws-ddk/release/stable/api/core/stubs/aws_ddk_core.pipelines.DataPipeline.html)
is a chained series of stages. It automatically “wires” the stages together using
[AWS EventBridge Rules](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-rules.html) .

DDK comes with a library of stages, however users can also create their own based on their use cases,
and are encouraged to share them with the community.

Let's take a look at an example below:

```python
...

firehose_s3_stage = KinesisToS3Stage(
    self,
    "ddk-firehose-s3",
    environment_id=environment_id,
    bucket=ddk_bucket,
    data_output_prefix="raw/",
)
sqs_lambda_stage = SqsToLambdaStage(
    scope=self,
    id="ddk-sqs-lambda",
    environment_id=environment_id,
    code=Code.from_asset("./lambda"),
    handler="index.lambda_handler",
    layers=[
        LayerVersion.from_layer_version_arn(
            self,
            "ddk-lambda-layer-wrangler",
            f"arn:aws:lambda:{self.region}:336392948345:layer:AWSDataWrangler-Python39:2",
        )
    ]
)

(
    DataPipeline(scope=self, id="ddk-pipeline")
    .add_stage(firehose_s3_stage)
    .add_stage(sqs_lambda_stage)
)
...
```

First, we import the required resources from the aws_ddk_core library, including the two stage constructs:
[KinesisToS3Stage](https://awslabs.github.io/aws-ddk/release/stable/api/core/stubs/aws_ddk_core.stages.KinesisToS3Stage.html), and
[SQSToLambdaStage()](https://awslabs.github.io/aws-ddk/release/stable/api/core/stubs/aws_ddk_core.stages.SqsToLambdaStage.html).
These two classes are then instantiated and the delivery stream is configured with the S3 prefix (raw/).
Finally, the DDK DataPipeline construct is used to chain these two stages together into a data pipeline.

Complete source code of the data pipeline above can be found in
[AWS DDK Examples - Basic Data Pipeline](https://github.com/aws-samples/aws-ddk-examples/tree/main/basic-data-pipeline)

### Resource Configuration

Another core feature of DDK is ability to provide environment-dependent configuration to your resources.

In the example below, we create Kinesis Data Stream using
[KinesisStreamsFactory](https://awslabs.github.io/aws-ddk/release/latest/api/core/stubs/aws_ddk_core.resources.KinesisStreamsFactory.html#aws_ddk_core.resources.KinesisStreamsFactory).

```python
...
from aws_ddk_core.resources import KinesisStreamsFactory

...
data_stream = KinesisStreamsFactory.data_stream(
    self, id=f"example-data-stream", environment_id=environment_id,
)
...
```

Resources created by DDK factories are automatically configured with properties from `ddk.json`.

```json
{
    "environments": {
        "test": {
            "account": "3333333333333",
            "region": "us-east-1",
            "resources": {
                "example-data-stream": {"shard_count": 5},
            }
        }
    }
}
```

In this example, the Kinesis Data Stream will be configured with `5` shards.

### Starting a new project

Install or update the AWS DDK from PyPi.

![pip install aws-ddk](./docs/source/_static/pip-install.gif)

Create a new project:

```console
ddk init sample-app
```

This will create a `sample-app` directory inside the current folder.
Inside that directory, it will generate the initial project structure, and initialize a virtual environment.

```console
sample-app
├── .gitignore
├── .venv
├── README.md
├── app.py
├── cdk.json
├── ddk.json
├── ddk_app
│   ├── __init__.py
│   └── ddk_app_stack.py
├── requirements-dev.txt
├── requirements.txt
├── setup.py
└── source.bat
```

To activate the virtual environment, and install the dependencies, run:

```console
source .venv/bin/activate && pip install -r requirements.txt
```

Next, let us examine the code. If you look at app.py, it will look like this:

```python
import aws_cdk as cdk
from ddk_app.ddk_app_stack import DdkApplicationStack

app = cdk.App()
DdkApplicationStack(app, "DdkApplication", "dev")

app.synth()
```

If your AWS account hasn't been used to deploy DDK apps before, then you need to bootstrap your environment:

```console
ddk bootstrap
```

You can then deploy your DDK app:

```console
ddk deploy
```

### Official Resources

* [Workshop](https://catalog.us-east-1.prod.workshops.aws/workshops/3644b48b-1d7c-43ef-a353-6edcd96385af/en-US)
* [Documentation](https://awslabs.github.io/aws-ddk/)
* [API Reference](https://awslabs.github.io/aws-ddk/release/stable/api/index)
* [Examples](https://github.com/aws-samples/aws-ddk-examples/)

## Getting Help

The best way to interact with our team is through GitHub.  You can open an issue and choose from one of our templates for bug reports, feature requests, or documentation issues.  If you have a feature request, don't forget you can search existing issues and upvote or comment on existing issues before creating a new one.

## Contributing

We welcome community contributions and pull requests.  Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for details on how to set up a development
environment and submit code.

## Other Ways to Support

One way you can support our project is by letting others know that your organisation uses the DDK.  If you would like us to include your company's name and/or logo in this README file, please raise a 'Support the DDK' issue.  Note that by raising a this issue (and related pull request), you are granting AWS permission to use your company’s name (and logo) for the limited purpose described here and you are confirming that you have authority to grant such permission.

## License

This project is licensed under the Apache-2.0 License.
'''
import abc
import builtins
import datetime
import enum
import typing

import jsii
import publication
import typing_extensions

from typeguard import check_type

from ._jsii import *

import aws_cdk as _aws_cdk_ceddda9d
import aws_cdk.aws_appflow as _aws_cdk_aws_appflow_ceddda9d
import aws_cdk.aws_cloudwatch as _aws_cdk_aws_cloudwatch_ceddda9d
import aws_cdk.aws_codeguruprofiler as _aws_cdk_aws_codeguruprofiler_ceddda9d
import aws_cdk.aws_codepipeline as _aws_cdk_aws_codepipeline_ceddda9d
import aws_cdk.aws_codestarnotifications as _aws_cdk_aws_codestarnotifications_ceddda9d
import aws_cdk.aws_databrew as _aws_cdk_aws_databrew_ceddda9d
import aws_cdk.aws_ec2 as _aws_cdk_aws_ec2_ceddda9d
import aws_cdk.aws_events as _aws_cdk_aws_events_ceddda9d
import aws_cdk.aws_glue as _aws_cdk_aws_glue_ceddda9d
import aws_cdk.aws_glue_alpha as _aws_cdk_aws_glue_alpha_ce674d29
import aws_cdk.aws_iam as _aws_cdk_aws_iam_ceddda9d
import aws_cdk.aws_kinesis as _aws_cdk_aws_kinesis_ceddda9d
import aws_cdk.aws_kinesisfirehose_alpha as _aws_cdk_aws_kinesisfirehose_alpha_30daaf29
import aws_cdk.aws_kinesisfirehose_destinations_alpha as _aws_cdk_aws_kinesisfirehose_destinations_alpha_8ee8dbdc
import aws_cdk.aws_kms as _aws_cdk_aws_kms_ceddda9d
import aws_cdk.aws_lambda as _aws_cdk_aws_lambda_ceddda9d
import aws_cdk.aws_logs as _aws_cdk_aws_logs_ceddda9d
import aws_cdk.aws_s3 as _aws_cdk_aws_s3_ceddda9d
import aws_cdk.aws_sns as _aws_cdk_aws_sns_ceddda9d
import aws_cdk.aws_sqs as _aws_cdk_aws_sqs_ceddda9d
import aws_cdk.aws_stepfunctions as _aws_cdk_aws_stepfunctions_ceddda9d
import aws_cdk.aws_stepfunctions_tasks as _aws_cdk_aws_stepfunctions_tasks_ceddda9d
import aws_cdk.pipelines as _aws_cdk_pipelines_ceddda9d
import constructs as _constructs_77d1e7e8


@jsii.data_type(
    jsii_type="aws-ddk-core.AddApplicationStageProps",
    jsii_struct_bases=[],
    name_mapping={
        "stage": "stage",
        "stage_id": "stageId",
        "manual_approvals": "manualApprovals",
    },
)
class AddApplicationStageProps:
    def __init__(
        self,
        *,
        stage: _aws_cdk_ceddda9d.Stage,
        stage_id: builtins.str,
        manual_approvals: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param stage: 
        :param stage_id: 
        :param manual_approvals: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b76c36dbcfdd4e997564efc9be54eb407b35cd3e027b00901b31d379e392170e)
            check_type(argname="argument stage", value=stage, expected_type=type_hints["stage"])
            check_type(argname="argument stage_id", value=stage_id, expected_type=type_hints["stage_id"])
            check_type(argname="argument manual_approvals", value=manual_approvals, expected_type=type_hints["manual_approvals"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "stage": stage,
            "stage_id": stage_id,
        }
        if manual_approvals is not None:
            self._values["manual_approvals"] = manual_approvals

    @builtins.property
    def stage(self) -> _aws_cdk_ceddda9d.Stage:
        result = self._values.get("stage")
        assert result is not None, "Required property 'stage' is missing"
        return typing.cast(_aws_cdk_ceddda9d.Stage, result)

    @builtins.property
    def stage_id(self) -> builtins.str:
        result = self._values.get("stage_id")
        assert result is not None, "Required property 'stage_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def manual_approvals(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("manual_approvals")
        return typing.cast(typing.Optional[builtins.bool], 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 "AddApplicationStageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.AddApplicationWaveProps",
    jsii_struct_bases=[],
    name_mapping={
        "stage_id": "stageId",
        "stages": "stages",
        "manual_approvals": "manualApprovals",
    },
)
class AddApplicationWaveProps:
    def __init__(
        self,
        *,
        stage_id: builtins.str,
        stages: typing.Sequence[_aws_cdk_ceddda9d.Stage],
        manual_approvals: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param stage_id: 
        :param stages: 
        :param manual_approvals: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1c5ca54834b066a96cdaae8f32086d4638af32527e6bdd7356e96d6b16db8c0d)
            check_type(argname="argument stage_id", value=stage_id, expected_type=type_hints["stage_id"])
            check_type(argname="argument stages", value=stages, expected_type=type_hints["stages"])
            check_type(argname="argument manual_approvals", value=manual_approvals, expected_type=type_hints["manual_approvals"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "stage_id": stage_id,
            "stages": stages,
        }
        if manual_approvals is not None:
            self._values["manual_approvals"] = manual_approvals

    @builtins.property
    def stage_id(self) -> builtins.str:
        result = self._values.get("stage_id")
        assert result is not None, "Required property 'stage_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def stages(self) -> typing.List[_aws_cdk_ceddda9d.Stage]:
        result = self._values.get("stages")
        assert result is not None, "Required property 'stages' is missing"
        return typing.cast(typing.List[_aws_cdk_ceddda9d.Stage], result)

    @builtins.property
    def manual_approvals(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("manual_approvals")
        return typing.cast(typing.Optional[builtins.bool], 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 "AddApplicationWaveProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.AddCustomStageProps",
    jsii_struct_bases=[],
    name_mapping={"stage_name": "stageName", "steps": "steps"},
)
class AddCustomStageProps:
    def __init__(
        self,
        *,
        stage_name: builtins.str,
        steps: typing.Sequence[_aws_cdk_pipelines_ceddda9d.Step],
    ) -> None:
        '''
        :param stage_name: 
        :param steps: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8660c7ffe37e5e521438a6f05e109d7d73960491ec724c71005fa435cb1ba0cb)
            check_type(argname="argument stage_name", value=stage_name, expected_type=type_hints["stage_name"])
            check_type(argname="argument steps", value=steps, expected_type=type_hints["steps"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "stage_name": stage_name,
            "steps": steps,
        }

    @builtins.property
    def stage_name(self) -> builtins.str:
        result = self._values.get("stage_name")
        assert result is not None, "Required property 'stage_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def steps(self) -> typing.List[_aws_cdk_pipelines_ceddda9d.Step]:
        result = self._values.get("steps")
        assert result is not None, "Required property 'steps' is missing"
        return typing.cast(typing.List[_aws_cdk_pipelines_ceddda9d.Step], 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 "AddCustomStageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.AddNotificationsProps",
    jsii_struct_bases=[],
    name_mapping={"notification_rule": "notificationRule"},
)
class AddNotificationsProps:
    def __init__(
        self,
        *,
        notification_rule: typing.Optional[_aws_cdk_aws_codestarnotifications_ceddda9d.NotificationRule] = None,
    ) -> None:
        '''
        :param notification_rule: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f6b36a0552668c2be6f5870fa1fc235676fcd1d8e1633ffdcd8fe2ab50a5eb9c)
            check_type(argname="argument notification_rule", value=notification_rule, expected_type=type_hints["notification_rule"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if notification_rule is not None:
            self._values["notification_rule"] = notification_rule

    @builtins.property
    def notification_rule(
        self,
    ) -> typing.Optional[_aws_cdk_aws_codestarnotifications_ceddda9d.NotificationRule]:
        result = self._values.get("notification_rule")
        return typing.cast(typing.Optional[_aws_cdk_aws_codestarnotifications_ceddda9d.NotificationRule], 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 "AddNotificationsProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.AddRuleProps",
    jsii_struct_bases=[],
    name_mapping={
        "event_pattern": "eventPattern",
        "event_targets": "eventTargets",
        "id": "id",
        "override_rule": "overrideRule",
        "rule_name": "ruleName",
        "schedule": "schedule",
    },
)
class AddRuleProps:
    def __init__(
        self,
        *,
        event_pattern: typing.Optional[typing.Union[_aws_cdk_aws_events_ceddda9d.EventPattern, typing.Dict[builtins.str, typing.Any]]] = None,
        event_targets: typing.Optional[typing.Sequence[_aws_cdk_aws_events_ceddda9d.IRuleTarget]] = None,
        id: typing.Optional[builtins.str] = None,
        override_rule: typing.Optional[_aws_cdk_aws_events_ceddda9d.IRule] = None,
        rule_name: typing.Optional[builtins.str] = None,
        schedule: typing.Optional[_aws_cdk_aws_events_ceddda9d.Schedule] = None,
    ) -> None:
        '''
        :param event_pattern: 
        :param event_targets: 
        :param id: 
        :param override_rule: 
        :param rule_name: 
        :param schedule: 
        '''
        if isinstance(event_pattern, dict):
            event_pattern = _aws_cdk_aws_events_ceddda9d.EventPattern(**event_pattern)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dc4d3cd99b8129cd1e9e86879e1aa4a9e7d0340f69bb169e136c78c563e397f5)
            check_type(argname="argument event_pattern", value=event_pattern, expected_type=type_hints["event_pattern"])
            check_type(argname="argument event_targets", value=event_targets, expected_type=type_hints["event_targets"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument override_rule", value=override_rule, expected_type=type_hints["override_rule"])
            check_type(argname="argument rule_name", value=rule_name, expected_type=type_hints["rule_name"])
            check_type(argname="argument schedule", value=schedule, expected_type=type_hints["schedule"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if event_pattern is not None:
            self._values["event_pattern"] = event_pattern
        if event_targets is not None:
            self._values["event_targets"] = event_targets
        if id is not None:
            self._values["id"] = id
        if override_rule is not None:
            self._values["override_rule"] = override_rule
        if rule_name is not None:
            self._values["rule_name"] = rule_name
        if schedule is not None:
            self._values["schedule"] = schedule

    @builtins.property
    def event_pattern(
        self,
    ) -> typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern]:
        result = self._values.get("event_pattern")
        return typing.cast(typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern], result)

    @builtins.property
    def event_targets(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]]:
        result = self._values.get("event_targets")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]], result)

    @builtins.property
    def id(self) -> typing.Optional[builtins.str]:
        result = self._values.get("id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_rule(self) -> typing.Optional[_aws_cdk_aws_events_ceddda9d.IRule]:
        result = self._values.get("override_rule")
        return typing.cast(typing.Optional[_aws_cdk_aws_events_ceddda9d.IRule], result)

    @builtins.property
    def rule_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("rule_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def schedule(self) -> typing.Optional[_aws_cdk_aws_events_ceddda9d.Schedule]:
        result = self._values.get("schedule")
        return typing.cast(typing.Optional[_aws_cdk_aws_events_ceddda9d.Schedule], 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 "AddRuleProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.AddSecurityLintStageProps",
    jsii_struct_bases=[],
    name_mapping={
        "cloud_assembly_file_set": "cloudAssemblyFileSet",
        "stage_name": "stageName",
    },
)
class AddSecurityLintStageProps:
    def __init__(
        self,
        *,
        cloud_assembly_file_set: typing.Optional[_aws_cdk_pipelines_ceddda9d.IFileSetProducer] = None,
        stage_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param cloud_assembly_file_set: 
        :param stage_name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f5c6a426f2b47035ddfb61265fb0fc5f914c183c57db8be19fd6917fe3755000)
            check_type(argname="argument cloud_assembly_file_set", value=cloud_assembly_file_set, expected_type=type_hints["cloud_assembly_file_set"])
            check_type(argname="argument stage_name", value=stage_name, expected_type=type_hints["stage_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if cloud_assembly_file_set is not None:
            self._values["cloud_assembly_file_set"] = cloud_assembly_file_set
        if stage_name is not None:
            self._values["stage_name"] = stage_name

    @builtins.property
    def cloud_assembly_file_set(
        self,
    ) -> typing.Optional[_aws_cdk_pipelines_ceddda9d.IFileSetProducer]:
        result = self._values.get("cloud_assembly_file_set")
        return typing.cast(typing.Optional[_aws_cdk_pipelines_ceddda9d.IFileSetProducer], result)

    @builtins.property
    def stage_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("stage_name")
        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 "AddSecurityLintStageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.AddStageProps",
    jsii_struct_bases=[],
    name_mapping={
        "stage": "stage",
        "override_rule": "overrideRule",
        "rule_name": "ruleName",
        "schedule": "schedule",
        "skip_rule": "skipRule",
    },
)
class AddStageProps:
    def __init__(
        self,
        *,
        stage: "Stage",
        override_rule: typing.Optional[_aws_cdk_aws_events_ceddda9d.IRule] = None,
        rule_name: typing.Optional[builtins.str] = None,
        schedule: typing.Optional[_aws_cdk_aws_events_ceddda9d.Schedule] = None,
        skip_rule: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param stage: 
        :param override_rule: 
        :param rule_name: 
        :param schedule: 
        :param skip_rule: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c40909713474fb0ac5879649d02b6b9b99cca8e07cc03cfb0ee3a2161cabd53f)
            check_type(argname="argument stage", value=stage, expected_type=type_hints["stage"])
            check_type(argname="argument override_rule", value=override_rule, expected_type=type_hints["override_rule"])
            check_type(argname="argument rule_name", value=rule_name, expected_type=type_hints["rule_name"])
            check_type(argname="argument schedule", value=schedule, expected_type=type_hints["schedule"])
            check_type(argname="argument skip_rule", value=skip_rule, expected_type=type_hints["skip_rule"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "stage": stage,
        }
        if override_rule is not None:
            self._values["override_rule"] = override_rule
        if rule_name is not None:
            self._values["rule_name"] = rule_name
        if schedule is not None:
            self._values["schedule"] = schedule
        if skip_rule is not None:
            self._values["skip_rule"] = skip_rule

    @builtins.property
    def stage(self) -> "Stage":
        result = self._values.get("stage")
        assert result is not None, "Required property 'stage' is missing"
        return typing.cast("Stage", result)

    @builtins.property
    def override_rule(self) -> typing.Optional[_aws_cdk_aws_events_ceddda9d.IRule]:
        result = self._values.get("override_rule")
        return typing.cast(typing.Optional[_aws_cdk_aws_events_ceddda9d.IRule], result)

    @builtins.property
    def rule_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("rule_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def schedule(self) -> typing.Optional[_aws_cdk_aws_events_ceddda9d.Schedule]:
        result = self._values.get("schedule")
        return typing.cast(typing.Optional[_aws_cdk_aws_events_ceddda9d.Schedule], result)

    @builtins.property
    def skip_rule(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("skip_rule")
        return typing.cast(typing.Optional[builtins.bool], 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 "AddStageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.AddTestStageProps",
    jsii_struct_bases=[],
    name_mapping={
        "cloud_assembly_file_set": "cloudAssemblyFileSet",
        "commands": "commands",
        "stage_name": "stageName",
    },
)
class AddTestStageProps:
    def __init__(
        self,
        *,
        cloud_assembly_file_set: typing.Optional[_aws_cdk_pipelines_ceddda9d.IFileSetProducer] = None,
        commands: typing.Optional[typing.Sequence[builtins.str]] = None,
        stage_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param cloud_assembly_file_set: 
        :param commands: 
        :param stage_name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0efd164879f28724d26fec5d40738d32540d827f1e7d46271d569f72a3a0a21f)
            check_type(argname="argument cloud_assembly_file_set", value=cloud_assembly_file_set, expected_type=type_hints["cloud_assembly_file_set"])
            check_type(argname="argument commands", value=commands, expected_type=type_hints["commands"])
            check_type(argname="argument stage_name", value=stage_name, expected_type=type_hints["stage_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if cloud_assembly_file_set is not None:
            self._values["cloud_assembly_file_set"] = cloud_assembly_file_set
        if commands is not None:
            self._values["commands"] = commands
        if stage_name is not None:
            self._values["stage_name"] = stage_name

    @builtins.property
    def cloud_assembly_file_set(
        self,
    ) -> typing.Optional[_aws_cdk_pipelines_ceddda9d.IFileSetProducer]:
        result = self._values.get("cloud_assembly_file_set")
        return typing.cast(typing.Optional[_aws_cdk_pipelines_ceddda9d.IFileSetProducer], result)

    @builtins.property
    def commands(self) -> typing.Optional[typing.List[builtins.str]]:
        result = self._values.get("commands")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def stage_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("stage_name")
        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 "AddTestStageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.AdditionalPipelineProps",
    jsii_struct_bases=[],
    name_mapping={
        "asset_publishing_code_build_defaults": "assetPublishingCodeBuildDefaults",
        "cli_version": "cliVersion",
        "code_build_defaults": "codeBuildDefaults",
        "code_pipeline": "codePipeline",
        "docker_credentials": "dockerCredentials",
        "docker_enabled_for_self_mutation": "dockerEnabledForSelfMutation",
        "docker_enabled_for_synth": "dockerEnabledForSynth",
        "publish_assets_in_parallel": "publishAssetsInParallel",
        "reuse_cross_region_support_stacks": "reuseCrossRegionSupportStacks",
        "self_mutation": "selfMutation",
        "self_mutation_code_build_defaults": "selfMutationCodeBuildDefaults",
        "synth_code_build_defaults": "synthCodeBuildDefaults",
    },
)
class AdditionalPipelineProps:
    def __init__(
        self,
        *,
        asset_publishing_code_build_defaults: typing.Optional[typing.Union[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions, typing.Dict[builtins.str, typing.Any]]] = None,
        cli_version: typing.Optional[builtins.str] = None,
        code_build_defaults: typing.Optional[typing.Union[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions, typing.Dict[builtins.str, typing.Any]]] = None,
        code_pipeline: typing.Optional[_aws_cdk_aws_codepipeline_ceddda9d.Pipeline] = None,
        docker_credentials: typing.Optional[typing.Sequence[_aws_cdk_pipelines_ceddda9d.DockerCredential]] = None,
        docker_enabled_for_self_mutation: typing.Optional[builtins.bool] = None,
        docker_enabled_for_synth: typing.Optional[builtins.bool] = None,
        publish_assets_in_parallel: typing.Optional[builtins.bool] = None,
        reuse_cross_region_support_stacks: typing.Optional[builtins.bool] = None,
        self_mutation: typing.Optional[builtins.bool] = None,
        self_mutation_code_build_defaults: typing.Optional[typing.Union[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions, typing.Dict[builtins.str, typing.Any]]] = None,
        synth_code_build_defaults: typing.Optional[typing.Union[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param asset_publishing_code_build_defaults: 
        :param cli_version: 
        :param code_build_defaults: 
        :param code_pipeline: 
        :param docker_credentials: 
        :param docker_enabled_for_self_mutation: 
        :param docker_enabled_for_synth: 
        :param publish_assets_in_parallel: 
        :param reuse_cross_region_support_stacks: 
        :param self_mutation: 
        :param self_mutation_code_build_defaults: 
        :param synth_code_build_defaults: 
        '''
        if isinstance(asset_publishing_code_build_defaults, dict):
            asset_publishing_code_build_defaults = _aws_cdk_pipelines_ceddda9d.CodeBuildOptions(**asset_publishing_code_build_defaults)
        if isinstance(code_build_defaults, dict):
            code_build_defaults = _aws_cdk_pipelines_ceddda9d.CodeBuildOptions(**code_build_defaults)
        if isinstance(self_mutation_code_build_defaults, dict):
            self_mutation_code_build_defaults = _aws_cdk_pipelines_ceddda9d.CodeBuildOptions(**self_mutation_code_build_defaults)
        if isinstance(synth_code_build_defaults, dict):
            synth_code_build_defaults = _aws_cdk_pipelines_ceddda9d.CodeBuildOptions(**synth_code_build_defaults)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__34c4dbaccc767dfa14746a2df4a90bdbf9d6318afb10cc0e8809c95f4447414b)
            check_type(argname="argument asset_publishing_code_build_defaults", value=asset_publishing_code_build_defaults, expected_type=type_hints["asset_publishing_code_build_defaults"])
            check_type(argname="argument cli_version", value=cli_version, expected_type=type_hints["cli_version"])
            check_type(argname="argument code_build_defaults", value=code_build_defaults, expected_type=type_hints["code_build_defaults"])
            check_type(argname="argument code_pipeline", value=code_pipeline, expected_type=type_hints["code_pipeline"])
            check_type(argname="argument docker_credentials", value=docker_credentials, expected_type=type_hints["docker_credentials"])
            check_type(argname="argument docker_enabled_for_self_mutation", value=docker_enabled_for_self_mutation, expected_type=type_hints["docker_enabled_for_self_mutation"])
            check_type(argname="argument docker_enabled_for_synth", value=docker_enabled_for_synth, expected_type=type_hints["docker_enabled_for_synth"])
            check_type(argname="argument publish_assets_in_parallel", value=publish_assets_in_parallel, expected_type=type_hints["publish_assets_in_parallel"])
            check_type(argname="argument reuse_cross_region_support_stacks", value=reuse_cross_region_support_stacks, expected_type=type_hints["reuse_cross_region_support_stacks"])
            check_type(argname="argument self_mutation", value=self_mutation, expected_type=type_hints["self_mutation"])
            check_type(argname="argument self_mutation_code_build_defaults", value=self_mutation_code_build_defaults, expected_type=type_hints["self_mutation_code_build_defaults"])
            check_type(argname="argument synth_code_build_defaults", value=synth_code_build_defaults, expected_type=type_hints["synth_code_build_defaults"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if asset_publishing_code_build_defaults is not None:
            self._values["asset_publishing_code_build_defaults"] = asset_publishing_code_build_defaults
        if cli_version is not None:
            self._values["cli_version"] = cli_version
        if code_build_defaults is not None:
            self._values["code_build_defaults"] = code_build_defaults
        if code_pipeline is not None:
            self._values["code_pipeline"] = code_pipeline
        if docker_credentials is not None:
            self._values["docker_credentials"] = docker_credentials
        if docker_enabled_for_self_mutation is not None:
            self._values["docker_enabled_for_self_mutation"] = docker_enabled_for_self_mutation
        if docker_enabled_for_synth is not None:
            self._values["docker_enabled_for_synth"] = docker_enabled_for_synth
        if publish_assets_in_parallel is not None:
            self._values["publish_assets_in_parallel"] = publish_assets_in_parallel
        if reuse_cross_region_support_stacks is not None:
            self._values["reuse_cross_region_support_stacks"] = reuse_cross_region_support_stacks
        if self_mutation is not None:
            self._values["self_mutation"] = self_mutation
        if self_mutation_code_build_defaults is not None:
            self._values["self_mutation_code_build_defaults"] = self_mutation_code_build_defaults
        if synth_code_build_defaults is not None:
            self._values["synth_code_build_defaults"] = synth_code_build_defaults

    @builtins.property
    def asset_publishing_code_build_defaults(
        self,
    ) -> typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions]:
        result = self._values.get("asset_publishing_code_build_defaults")
        return typing.cast(typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions], result)

    @builtins.property
    def cli_version(self) -> typing.Optional[builtins.str]:
        result = self._values.get("cli_version")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def code_build_defaults(
        self,
    ) -> typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions]:
        result = self._values.get("code_build_defaults")
        return typing.cast(typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions], result)

    @builtins.property
    def code_pipeline(
        self,
    ) -> typing.Optional[_aws_cdk_aws_codepipeline_ceddda9d.Pipeline]:
        result = self._values.get("code_pipeline")
        return typing.cast(typing.Optional[_aws_cdk_aws_codepipeline_ceddda9d.Pipeline], result)

    @builtins.property
    def docker_credentials(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_pipelines_ceddda9d.DockerCredential]]:
        result = self._values.get("docker_credentials")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_pipelines_ceddda9d.DockerCredential]], result)

    @builtins.property
    def docker_enabled_for_self_mutation(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("docker_enabled_for_self_mutation")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def docker_enabled_for_synth(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("docker_enabled_for_synth")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def publish_assets_in_parallel(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("publish_assets_in_parallel")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def reuse_cross_region_support_stacks(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("reuse_cross_region_support_stacks")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def self_mutation(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("self_mutation")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def self_mutation_code_build_defaults(
        self,
    ) -> typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions]:
        result = self._values.get("self_mutation_code_build_defaults")
        return typing.cast(typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions], result)

    @builtins.property
    def synth_code_build_defaults(
        self,
    ) -> typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions]:
        result = self._values.get("synth_code_build_defaults")
        return typing.cast(typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions], 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 "AdditionalPipelineProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.AlarmProps",
    jsii_struct_bases=[],
    name_mapping={
        "metric": "metric",
        "comparison_operator": "comparisonOperator",
        "evaluation_periods": "evaluationPeriods",
        "threshold": "threshold",
    },
)
class AlarmProps:
    def __init__(
        self,
        *,
        metric: _aws_cdk_aws_cloudwatch_ceddda9d.IMetric,
        comparison_operator: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        threshold: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param metric: 
        :param comparison_operator: 
        :param evaluation_periods: 
        :param threshold: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9739513f93590856f8f02851ab5bfe24bf3c845f3e37410565b3668ac8406da2)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument comparison_operator", value=comparison_operator, expected_type=type_hints["comparison_operator"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument threshold", value=threshold, expected_type=type_hints["threshold"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "metric": metric,
        }
        if comparison_operator is not None:
            self._values["comparison_operator"] = comparison_operator
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if threshold is not None:
            self._values["threshold"] = threshold

    @builtins.property
    def metric(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.IMetric:
        result = self._values.get("metric")
        assert result is not None, "Required property 'metric' is missing"
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.IMetric, result)

    @builtins.property
    def comparison_operator(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        result = self._values.get("comparison_operator")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def threshold(self) -> typing.Optional[jsii.Number]:
        result = self._values.get("threshold")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AlarmProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class BaseStack(
    _aws_cdk_ceddda9d.Stack,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-ddk-core.BaseStack",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        config: typing.Optional[typing.Union[builtins.str, typing.Union["Configuration", typing.Dict[builtins.str, typing.Any]]]] = None,
        environment_id: typing.Optional[builtins.str] = None,
        permissions_boundary_arn: typing.Optional[builtins.str] = None,
        analytics_reporting: typing.Optional[builtins.bool] = None,
        cross_region_references: typing.Optional[builtins.bool] = None,
        description: typing.Optional[builtins.str] = None,
        env: typing.Optional[typing.Union[_aws_cdk_ceddda9d.Environment, typing.Dict[builtins.str, typing.Any]]] = None,
        permissions_boundary: typing.Optional[_aws_cdk_ceddda9d.PermissionsBoundary] = None,
        stack_name: typing.Optional[builtins.str] = None,
        synthesizer: typing.Optional[_aws_cdk_ceddda9d.IStackSynthesizer] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        termination_protection: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param config: 
        :param environment_id: 
        :param permissions_boundary_arn: 
        :param analytics_reporting: Include runtime versioning information in this Stack. Default: ``analyticsReporting`` setting of containing ``App``, or value of 'aws:cdk:version-reporting' context key
        :param cross_region_references: Enable this flag to allow native cross region stack references. Enabling this will create a CloudFormation custom resource in both the producing stack and consuming stack in order to perform the export/import This feature is currently experimental Default: false
        :param description: A description of the stack. Default: - No description.
        :param env: The AWS environment (account/region) where this stack will be deployed. Set the ``region``/``account`` fields of ``env`` to either a concrete value to select the indicated environment (recommended for production stacks), or to the values of environment variables ``CDK_DEFAULT_REGION``/``CDK_DEFAULT_ACCOUNT`` to let the target environment depend on the AWS credentials/configuration that the CDK CLI is executed under (recommended for development stacks). If the ``Stack`` is instantiated inside a ``Stage``, any undefined ``region``/``account`` fields from ``env`` will default to the same field on the encompassing ``Stage``, if configured there. If either ``region`` or ``account`` are not set nor inherited from ``Stage``, the Stack will be considered "*environment-agnostic*"". Environment-agnostic stacks can be deployed to any environment but may not be able to take advantage of all features of the CDK. For example, they will not be able to use environmental context lookups such as ``ec2.Vpc.fromLookup`` and will not automatically translate Service Principals to the right format based on the environment's AWS partition, and other such enhancements. Default: - The environment of the containing ``Stage`` if available, otherwise create the stack will be environment-agnostic.
        :param permissions_boundary: Options for applying a permissions boundary to all IAM Roles and Users created within this Stage. Default: - no permissions boundary is applied
        :param stack_name: Name to deploy the stack with. Default: - Derived from construct path.
        :param synthesizer: Synthesis method to use while deploying this stack. The Stack Synthesizer controls aspects of synthesis and deployment, like how assets are referenced and what IAM roles to use. For more information, see the README of the main CDK package. If not specified, the ``defaultStackSynthesizer`` from ``App`` will be used. If that is not specified, ``DefaultStackSynthesizer`` is used if ``@aws-cdk/core:newStyleStackSynthesis`` is set to ``true`` or the CDK major version is v2. In CDK v1 ``LegacyStackSynthesizer`` is the default if no other synthesizer is specified. Default: - The synthesizer specified on ``App``, or ``DefaultStackSynthesizer`` otherwise.
        :param tags: Stack tags that will be applied to all the taggable resources and the stack itself. Default: {}
        :param termination_protection: Whether to enable termination protection for this stack. Default: false
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__403bc1fd4d529dd1acdcfdf6824076a7e78329d131f442981f447f8f5298a7cc)
            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 = BaseStackProps(
            config=config,
            environment_id=environment_id,
            permissions_boundary_arn=permissions_boundary_arn,
            analytics_reporting=analytics_reporting,
            cross_region_references=cross_region_references,
            description=description,
            env=env,
            permissions_boundary=permissions_boundary,
            stack_name=stack_name,
            synthesizer=synthesizer,
            tags=tags,
            termination_protection=termination_protection,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="createDefaultPermissionsBoundary")
    @builtins.classmethod
    def create_default_permissions_boundary(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        environment_id: typing.Optional[builtins.str] = None,
        prefix: typing.Optional[builtins.str] = None,
        qualifier: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_aws_iam_ceddda9d.IManagedPolicy:
        '''
        :param scope: -
        :param id: -
        :param environment_id: 
        :param prefix: 
        :param qualifier: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c52c78b6e97cce4b370cb75d9552fff81495ba02218c70f1c8947488c2c0604a)
            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 = PermissionsBoundaryProps(
            environment_id=environment_id, prefix=prefix, qualifier=qualifier
        )

        return typing.cast(_aws_cdk_aws_iam_ceddda9d.IManagedPolicy, jsii.sinvoke(cls, "createDefaultPermissionsBoundary", [scope, id, props]))

    @builtins.property
    @jsii.member(jsii_name="terminationProtection")
    def termination_protection(self) -> typing.Optional[builtins.bool]:
        '''Whether termination protection is enabled for this stack.'''
        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "terminationProtection"))


@jsii.data_type(
    jsii_type="aws-ddk-core.BaseStackProps",
    jsii_struct_bases=[_aws_cdk_ceddda9d.StackProps],
    name_mapping={
        "analytics_reporting": "analyticsReporting",
        "cross_region_references": "crossRegionReferences",
        "description": "description",
        "env": "env",
        "permissions_boundary": "permissionsBoundary",
        "stack_name": "stackName",
        "synthesizer": "synthesizer",
        "tags": "tags",
        "termination_protection": "terminationProtection",
        "config": "config",
        "environment_id": "environmentId",
        "permissions_boundary_arn": "permissionsBoundaryArn",
    },
)
class BaseStackProps(_aws_cdk_ceddda9d.StackProps):
    def __init__(
        self,
        *,
        analytics_reporting: typing.Optional[builtins.bool] = None,
        cross_region_references: typing.Optional[builtins.bool] = None,
        description: typing.Optional[builtins.str] = None,
        env: typing.Optional[typing.Union[_aws_cdk_ceddda9d.Environment, typing.Dict[builtins.str, typing.Any]]] = None,
        permissions_boundary: typing.Optional[_aws_cdk_ceddda9d.PermissionsBoundary] = None,
        stack_name: typing.Optional[builtins.str] = None,
        synthesizer: typing.Optional[_aws_cdk_ceddda9d.IStackSynthesizer] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        termination_protection: typing.Optional[builtins.bool] = None,
        config: typing.Optional[typing.Union[builtins.str, typing.Union["Configuration", typing.Dict[builtins.str, typing.Any]]]] = None,
        environment_id: typing.Optional[builtins.str] = None,
        permissions_boundary_arn: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param analytics_reporting: Include runtime versioning information in this Stack. Default: ``analyticsReporting`` setting of containing ``App``, or value of 'aws:cdk:version-reporting' context key
        :param cross_region_references: Enable this flag to allow native cross region stack references. Enabling this will create a CloudFormation custom resource in both the producing stack and consuming stack in order to perform the export/import This feature is currently experimental Default: false
        :param description: A description of the stack. Default: - No description.
        :param env: The AWS environment (account/region) where this stack will be deployed. Set the ``region``/``account`` fields of ``env`` to either a concrete value to select the indicated environment (recommended for production stacks), or to the values of environment variables ``CDK_DEFAULT_REGION``/``CDK_DEFAULT_ACCOUNT`` to let the target environment depend on the AWS credentials/configuration that the CDK CLI is executed under (recommended for development stacks). If the ``Stack`` is instantiated inside a ``Stage``, any undefined ``region``/``account`` fields from ``env`` will default to the same field on the encompassing ``Stage``, if configured there. If either ``region`` or ``account`` are not set nor inherited from ``Stage``, the Stack will be considered "*environment-agnostic*"". Environment-agnostic stacks can be deployed to any environment but may not be able to take advantage of all features of the CDK. For example, they will not be able to use environmental context lookups such as ``ec2.Vpc.fromLookup`` and will not automatically translate Service Principals to the right format based on the environment's AWS partition, and other such enhancements. Default: - The environment of the containing ``Stage`` if available, otherwise create the stack will be environment-agnostic.
        :param permissions_boundary: Options for applying a permissions boundary to all IAM Roles and Users created within this Stage. Default: - no permissions boundary is applied
        :param stack_name: Name to deploy the stack with. Default: - Derived from construct path.
        :param synthesizer: Synthesis method to use while deploying this stack. The Stack Synthesizer controls aspects of synthesis and deployment, like how assets are referenced and what IAM roles to use. For more information, see the README of the main CDK package. If not specified, the ``defaultStackSynthesizer`` from ``App`` will be used. If that is not specified, ``DefaultStackSynthesizer`` is used if ``@aws-cdk/core:newStyleStackSynthesis`` is set to ``true`` or the CDK major version is v2. In CDK v1 ``LegacyStackSynthesizer`` is the default if no other synthesizer is specified. Default: - The synthesizer specified on ``App``, or ``DefaultStackSynthesizer`` otherwise.
        :param tags: Stack tags that will be applied to all the taggable resources and the stack itself. Default: {}
        :param termination_protection: Whether to enable termination protection for this stack. Default: false
        :param config: 
        :param environment_id: 
        :param permissions_boundary_arn: 
        '''
        if isinstance(env, dict):
            env = _aws_cdk_ceddda9d.Environment(**env)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a429ca722d1fec889b8120d065d6c339e922faac9a9e70454e565500ff82514c)
            check_type(argname="argument analytics_reporting", value=analytics_reporting, expected_type=type_hints["analytics_reporting"])
            check_type(argname="argument cross_region_references", value=cross_region_references, expected_type=type_hints["cross_region_references"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument env", value=env, expected_type=type_hints["env"])
            check_type(argname="argument permissions_boundary", value=permissions_boundary, expected_type=type_hints["permissions_boundary"])
            check_type(argname="argument stack_name", value=stack_name, expected_type=type_hints["stack_name"])
            check_type(argname="argument synthesizer", value=synthesizer, expected_type=type_hints["synthesizer"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument termination_protection", value=termination_protection, expected_type=type_hints["termination_protection"])
            check_type(argname="argument config", value=config, expected_type=type_hints["config"])
            check_type(argname="argument environment_id", value=environment_id, expected_type=type_hints["environment_id"])
            check_type(argname="argument permissions_boundary_arn", value=permissions_boundary_arn, expected_type=type_hints["permissions_boundary_arn"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if analytics_reporting is not None:
            self._values["analytics_reporting"] = analytics_reporting
        if cross_region_references is not None:
            self._values["cross_region_references"] = cross_region_references
        if description is not None:
            self._values["description"] = description
        if env is not None:
            self._values["env"] = env
        if permissions_boundary is not None:
            self._values["permissions_boundary"] = permissions_boundary
        if stack_name is not None:
            self._values["stack_name"] = stack_name
        if synthesizer is not None:
            self._values["synthesizer"] = synthesizer
        if tags is not None:
            self._values["tags"] = tags
        if termination_protection is not None:
            self._values["termination_protection"] = termination_protection
        if config is not None:
            self._values["config"] = config
        if environment_id is not None:
            self._values["environment_id"] = environment_id
        if permissions_boundary_arn is not None:
            self._values["permissions_boundary_arn"] = permissions_boundary_arn

    @builtins.property
    def analytics_reporting(self) -> typing.Optional[builtins.bool]:
        '''Include runtime versioning information in this Stack.

        :default:

        ``analyticsReporting`` setting of containing ``App``, or value of
        'aws:cdk:version-reporting' context key
        '''
        result = self._values.get("analytics_reporting")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def cross_region_references(self) -> typing.Optional[builtins.bool]:
        '''Enable this flag to allow native cross region stack references.

        Enabling this will create a CloudFormation custom resource
        in both the producing stack and consuming stack in order to perform the export/import

        This feature is currently experimental

        :default: false
        '''
        result = self._values.get("cross_region_references")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A description of the stack.

        :default: - No description.
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def env(self) -> typing.Optional[_aws_cdk_ceddda9d.Environment]:
        '''The AWS environment (account/region) where this stack will be deployed.

        Set the ``region``/``account`` fields of ``env`` to either a concrete value to
        select the indicated environment (recommended for production stacks), or to
        the values of environment variables
        ``CDK_DEFAULT_REGION``/``CDK_DEFAULT_ACCOUNT`` to let the target environment
        depend on the AWS credentials/configuration that the CDK CLI is executed
        under (recommended for development stacks).

        If the ``Stack`` is instantiated inside a ``Stage``, any undefined
        ``region``/``account`` fields from ``env`` will default to the same field on the
        encompassing ``Stage``, if configured there.

        If either ``region`` or ``account`` are not set nor inherited from ``Stage``, the
        Stack will be considered "*environment-agnostic*"". Environment-agnostic
        stacks can be deployed to any environment but may not be able to take
        advantage of all features of the CDK. For example, they will not be able to
        use environmental context lookups such as ``ec2.Vpc.fromLookup`` and will not
        automatically translate Service Principals to the right format based on the
        environment's AWS partition, and other such enhancements.

        :default:

        - The environment of the containing ``Stage`` if available,
        otherwise create the stack will be environment-agnostic.

        Example::

            // Use a concrete account and region to deploy this stack to:
            // `.account` and `.region` will simply return these values.
            new Stack(app, 'Stack1', {
              env: {
                account: '123456789012',
                region: 'us-east-1'
              },
            });
            
            // Use the CLI's current credentials to determine the target environment:
            // `.account` and `.region` will reflect the account+region the CLI
            // is configured to use (based on the user CLI credentials)
            new Stack(app, 'Stack2', {
              env: {
                account: process.env.CDK_DEFAULT_ACCOUNT,
                region: process.env.CDK_DEFAULT_REGION
              },
            });
            
            // Define multiple stacks stage associated with an environment
            const myStage = new Stage(app, 'MyStage', {
              env: {
                account: '123456789012',
                region: 'us-east-1'
              }
            });
            
            // both of these stacks will use the stage's account/region:
            // `.account` and `.region` will resolve to the concrete values as above
            new MyStack(myStage, 'Stack1');
            new YourStack(myStage, 'Stack2');
            
            // Define an environment-agnostic stack:
            // `.account` and `.region` will resolve to `{ "Ref": "AWS::AccountId" }` and `{ "Ref": "AWS::Region" }` respectively.
            // which will only resolve to actual values by CloudFormation during deployment.
            new MyStack(app, 'Stack1');
        '''
        result = self._values.get("env")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Environment], result)

    @builtins.property
    def permissions_boundary(
        self,
    ) -> typing.Optional[_aws_cdk_ceddda9d.PermissionsBoundary]:
        '''Options for applying a permissions boundary to all IAM Roles and Users created within this Stage.

        :default: - no permissions boundary is applied
        '''
        result = self._values.get("permissions_boundary")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.PermissionsBoundary], result)

    @builtins.property
    def stack_name(self) -> typing.Optional[builtins.str]:
        '''Name to deploy the stack with.

        :default: - Derived from construct path.
        '''
        result = self._values.get("stack_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def synthesizer(self) -> typing.Optional[_aws_cdk_ceddda9d.IStackSynthesizer]:
        '''Synthesis method to use while deploying this stack.

        The Stack Synthesizer controls aspects of synthesis and deployment,
        like how assets are referenced and what IAM roles to use. For more
        information, see the README of the main CDK package.

        If not specified, the ``defaultStackSynthesizer`` from ``App`` will be used.
        If that is not specified, ``DefaultStackSynthesizer`` is used if
        ``@aws-cdk/core:newStyleStackSynthesis`` is set to ``true`` or the CDK major
        version is v2. In CDK v1 ``LegacyStackSynthesizer`` is the default if no
        other synthesizer is specified.

        :default: - The synthesizer specified on ``App``, or ``DefaultStackSynthesizer`` otherwise.
        '''
        result = self._values.get("synthesizer")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.IStackSynthesizer], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        '''Stack tags that will be applied to all the taggable resources and the stack itself.

        :default: {}
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    @builtins.property
    def termination_protection(self) -> typing.Optional[builtins.bool]:
        '''Whether to enable termination protection for this stack.

        :default: false
        '''
        result = self._values.get("termination_protection")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def config(self) -> typing.Optional[typing.Union[builtins.str, "Configuration"]]:
        result = self._values.get("config")
        return typing.cast(typing.Optional[typing.Union[builtins.str, "Configuration"]], result)

    @builtins.property
    def environment_id(self) -> typing.Optional[builtins.str]:
        result = self._values.get("environment_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def permissions_boundary_arn(self) -> typing.Optional[builtins.str]:
        result = self._values.get("permissions_boundary_arn")
        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 "BaseStackProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class CICDActions(metaclass=jsii.JSIIMeta, jsii_type="aws-ddk-core.CICDActions"):
    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="getBanditAction")
    @builtins.classmethod
    def get_bandit_action(
        cls,
        code_pipeline_source: _aws_cdk_pipelines_ceddda9d.CodePipelineSource,
        stage_name: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_pipelines_ceddda9d.ShellStep:
        '''
        :param code_pipeline_source: -
        :param stage_name: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fab9ea5d8746e6c137eb1d92124b75da65dab030241ebf0002427b6ad8676aa2)
            check_type(argname="argument code_pipeline_source", value=code_pipeline_source, expected_type=type_hints["code_pipeline_source"])
            check_type(argname="argument stage_name", value=stage_name, expected_type=type_hints["stage_name"])
        return typing.cast(_aws_cdk_pipelines_ceddda9d.ShellStep, jsii.sinvoke(cls, "getBanditAction", [code_pipeline_source, stage_name]))

    @jsii.member(jsii_name="getCfnNagAction")
    @builtins.classmethod
    def get_cfn_nag_action(
        cls,
        file_set_producer: _aws_cdk_pipelines_ceddda9d.IFileSetProducer,
        stage_name: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_pipelines_ceddda9d.ShellStep:
        '''
        :param file_set_producer: -
        :param stage_name: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ebe600cfab48179494151cd33416082a904aa73df681b93f5266545008838275)
            check_type(argname="argument file_set_producer", value=file_set_producer, expected_type=type_hints["file_set_producer"])
            check_type(argname="argument stage_name", value=stage_name, expected_type=type_hints["stage_name"])
        return typing.cast(_aws_cdk_pipelines_ceddda9d.ShellStep, jsii.sinvoke(cls, "getCfnNagAction", [file_set_producer, stage_name]))

    @jsii.member(jsii_name="getCodeArtifactPublishAction")
    @builtins.classmethod
    def get_code_artifact_publish_action(
        cls,
        partition: builtins.str,
        region: builtins.str,
        account: builtins.str,
        codeartifact_repository: builtins.str,
        codeartifact_domain: builtins.str,
        codeartifact_domain_owner: builtins.str,
        code_pipeline_source: typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipelineSource] = None,
        role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    ) -> _aws_cdk_pipelines_ceddda9d.CodeBuildStep:
        '''
        :param partition: -
        :param region: -
        :param account: -
        :param codeartifact_repository: -
        :param codeartifact_domain: -
        :param codeartifact_domain_owner: -
        :param code_pipeline_source: -
        :param role_policy_statements: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__203dfc08c6a839aacb072ea162bb03ae398d33f465cc8723ee83f36c65bf9fc8)
            check_type(argname="argument partition", value=partition, expected_type=type_hints["partition"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument codeartifact_repository", value=codeartifact_repository, expected_type=type_hints["codeartifact_repository"])
            check_type(argname="argument codeartifact_domain", value=codeartifact_domain, expected_type=type_hints["codeartifact_domain"])
            check_type(argname="argument codeartifact_domain_owner", value=codeartifact_domain_owner, expected_type=type_hints["codeartifact_domain_owner"])
            check_type(argname="argument code_pipeline_source", value=code_pipeline_source, expected_type=type_hints["code_pipeline_source"])
            check_type(argname="argument role_policy_statements", value=role_policy_statements, expected_type=type_hints["role_policy_statements"])
        return typing.cast(_aws_cdk_pipelines_ceddda9d.CodeBuildStep, jsii.sinvoke(cls, "getCodeArtifactPublishAction", [partition, region, account, codeartifact_repository, codeartifact_domain, codeartifact_domain_owner, code_pipeline_source, role_policy_statements]))

    @jsii.member(jsii_name="getCodeCommitSourceAction")
    @builtins.classmethod
    def get_code_commit_source_action(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        *,
        branch: builtins.str,
        repository_name: builtins.str,
        props: typing.Optional[typing.Union[_aws_cdk_pipelines_ceddda9d.ConnectionSourceOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> _aws_cdk_pipelines_ceddda9d.CodePipelineSource:
        '''
        :param scope: -
        :param branch: 
        :param repository_name: 
        :param props: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__299e24a53c04aec79676a22aae09e979fe6ffa8af8ec8306445500237732a145)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props_ = CodeCommitSourceActionProps(
            branch=branch, repository_name=repository_name, props=props
        )

        return typing.cast(_aws_cdk_pipelines_ceddda9d.CodePipelineSource, jsii.sinvoke(cls, "getCodeCommitSourceAction", [scope, props_]))

    @jsii.member(jsii_name="getSynthAction")
    @builtins.classmethod
    def get_synth_action(
        cls,
        *,
        account: typing.Optional[builtins.str] = None,
        additional_install_commands: typing.Optional[typing.Sequence[builtins.str]] = None,
        cdk_version: typing.Optional[builtins.str] = None,
        codeartifact_domain: typing.Optional[builtins.str] = None,
        codeartifact_domain_owner: typing.Optional[builtins.str] = None,
        codeartifact_repository: typing.Optional[builtins.str] = None,
        code_pipeline_source: typing.Optional[_aws_cdk_pipelines_ceddda9d.IFileSetProducer] = None,
        partition: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    ) -> _aws_cdk_pipelines_ceddda9d.CodeBuildStep:
        '''
        :param account: 
        :param additional_install_commands: 
        :param cdk_version: 
        :param codeartifact_domain: 
        :param codeartifact_domain_owner: 
        :param codeartifact_repository: 
        :param code_pipeline_source: 
        :param partition: 
        :param region: 
        :param role_policy_statements: 
        '''
        props = GetSynthActionProps(
            account=account,
            additional_install_commands=additional_install_commands,
            cdk_version=cdk_version,
            codeartifact_domain=codeartifact_domain,
            codeartifact_domain_owner=codeartifact_domain_owner,
            codeartifact_repository=codeartifact_repository,
            code_pipeline_source=code_pipeline_source,
            partition=partition,
            region=region,
            role_policy_statements=role_policy_statements,
        )

        return typing.cast(_aws_cdk_pipelines_ceddda9d.CodeBuildStep, jsii.sinvoke(cls, "getSynthAction", [props]))

    @jsii.member(jsii_name="getTestsAction")
    @builtins.classmethod
    def get_tests_action(
        cls,
        file_set_producer: _aws_cdk_pipelines_ceddda9d.IFileSetProducer,
        commands: typing.Optional[typing.Sequence[builtins.str]] = None,
        install_commands: typing.Optional[typing.Sequence[builtins.str]] = None,
        stage_name: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_pipelines_ceddda9d.ShellStep:
        '''
        :param file_set_producer: -
        :param commands: -
        :param install_commands: -
        :param stage_name: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__906b3057114921fd5b8c18404d27778ac3f64ce364e27565682c6ab1bac71b7b)
            check_type(argname="argument file_set_producer", value=file_set_producer, expected_type=type_hints["file_set_producer"])
            check_type(argname="argument commands", value=commands, expected_type=type_hints["commands"])
            check_type(argname="argument install_commands", value=install_commands, expected_type=type_hints["install_commands"])
            check_type(argname="argument stage_name", value=stage_name, expected_type=type_hints["stage_name"])
        return typing.cast(_aws_cdk_pipelines_ceddda9d.ShellStep, jsii.sinvoke(cls, "getTestsAction", [file_set_producer, commands, install_commands, stage_name]))


class CICDPipelineStack(
    BaseStack,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-ddk-core.CICDPipelineStack",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        cdk_language: typing.Optional[builtins.str] = None,
        pipeline_name: typing.Optional[builtins.str] = None,
        config: typing.Optional[typing.Union[builtins.str, typing.Union["Configuration", typing.Dict[builtins.str, typing.Any]]]] = None,
        environment_id: typing.Optional[builtins.str] = None,
        permissions_boundary_arn: typing.Optional[builtins.str] = None,
        analytics_reporting: typing.Optional[builtins.bool] = None,
        cross_region_references: typing.Optional[builtins.bool] = None,
        description: typing.Optional[builtins.str] = None,
        env: typing.Optional[typing.Union[_aws_cdk_ceddda9d.Environment, typing.Dict[builtins.str, typing.Any]]] = None,
        permissions_boundary: typing.Optional[_aws_cdk_ceddda9d.PermissionsBoundary] = None,
        stack_name: typing.Optional[builtins.str] = None,
        synthesizer: typing.Optional[_aws_cdk_ceddda9d.IStackSynthesizer] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        termination_protection: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param cdk_language: 
        :param pipeline_name: 
        :param config: 
        :param environment_id: 
        :param permissions_boundary_arn: 
        :param analytics_reporting: Include runtime versioning information in this Stack. Default: ``analyticsReporting`` setting of containing ``App``, or value of 'aws:cdk:version-reporting' context key
        :param cross_region_references: Enable this flag to allow native cross region stack references. Enabling this will create a CloudFormation custom resource in both the producing stack and consuming stack in order to perform the export/import This feature is currently experimental Default: false
        :param description: A description of the stack. Default: - No description.
        :param env: The AWS environment (account/region) where this stack will be deployed. Set the ``region``/``account`` fields of ``env`` to either a concrete value to select the indicated environment (recommended for production stacks), or to the values of environment variables ``CDK_DEFAULT_REGION``/``CDK_DEFAULT_ACCOUNT`` to let the target environment depend on the AWS credentials/configuration that the CDK CLI is executed under (recommended for development stacks). If the ``Stack`` is instantiated inside a ``Stage``, any undefined ``region``/``account`` fields from ``env`` will default to the same field on the encompassing ``Stage``, if configured there. If either ``region`` or ``account`` are not set nor inherited from ``Stage``, the Stack will be considered "*environment-agnostic*"". Environment-agnostic stacks can be deployed to any environment but may not be able to take advantage of all features of the CDK. For example, they will not be able to use environmental context lookups such as ``ec2.Vpc.fromLookup`` and will not automatically translate Service Principals to the right format based on the environment's AWS partition, and other such enhancements. Default: - The environment of the containing ``Stage`` if available, otherwise create the stack will be environment-agnostic.
        :param permissions_boundary: Options for applying a permissions boundary to all IAM Roles and Users created within this Stage. Default: - no permissions boundary is applied
        :param stack_name: Name to deploy the stack with. Default: - Derived from construct path.
        :param synthesizer: Synthesis method to use while deploying this stack. The Stack Synthesizer controls aspects of synthesis and deployment, like how assets are referenced and what IAM roles to use. For more information, see the README of the main CDK package. If not specified, the ``defaultStackSynthesizer`` from ``App`` will be used. If that is not specified, ``DefaultStackSynthesizer`` is used if ``@aws-cdk/core:newStyleStackSynthesis`` is set to ``true`` or the CDK major version is v2. In CDK v1 ``LegacyStackSynthesizer`` is the default if no other synthesizer is specified. Default: - The synthesizer specified on ``App``, or ``DefaultStackSynthesizer`` otherwise.
        :param tags: Stack tags that will be applied to all the taggable resources and the stack itself. Default: {}
        :param termination_protection: Whether to enable termination protection for this stack. Default: false
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2a4f7374970c6409060af558e7802348870a4c4a3b9f9232e789f1488d18fb90)
            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 = CICDPipelineStackProps(
            cdk_language=cdk_language,
            pipeline_name=pipeline_name,
            config=config,
            environment_id=environment_id,
            permissions_boundary_arn=permissions_boundary_arn,
            analytics_reporting=analytics_reporting,
            cross_region_references=cross_region_references,
            description=description,
            env=env,
            permissions_boundary=permissions_boundary,
            stack_name=stack_name,
            synthesizer=synthesizer,
            tags=tags,
            termination_protection=termination_protection,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="addChecks")
    def add_checks(self) -> "CICDPipelineStack":
        return typing.cast("CICDPipelineStack", jsii.invoke(self, "addChecks", []))

    @jsii.member(jsii_name="addCustomStage")
    def add_custom_stage(
        self,
        *,
        stage_name: builtins.str,
        steps: typing.Sequence[_aws_cdk_pipelines_ceddda9d.Step],
    ) -> "CICDPipelineStack":
        '''
        :param stage_name: 
        :param steps: 
        '''
        props = AddCustomStageProps(stage_name=stage_name, steps=steps)

        return typing.cast("CICDPipelineStack", jsii.invoke(self, "addCustomStage", [props]))

    @jsii.member(jsii_name="addNotifications")
    def add_notifications(
        self,
        *,
        notification_rule: typing.Optional[_aws_cdk_aws_codestarnotifications_ceddda9d.NotificationRule] = None,
    ) -> "CICDPipelineStack":
        '''
        :param notification_rule: 
        '''
        props = AddNotificationsProps(notification_rule=notification_rule)

        return typing.cast("CICDPipelineStack", jsii.invoke(self, "addNotifications", [props]))

    @jsii.member(jsii_name="addSecurityLintStage")
    def add_security_lint_stage(
        self,
        *,
        cloud_assembly_file_set: typing.Optional[_aws_cdk_pipelines_ceddda9d.IFileSetProducer] = None,
        stage_name: typing.Optional[builtins.str] = None,
    ) -> "CICDPipelineStack":
        '''
        :param cloud_assembly_file_set: 
        :param stage_name: 
        '''
        props = AddSecurityLintStageProps(
            cloud_assembly_file_set=cloud_assembly_file_set, stage_name=stage_name
        )

        return typing.cast("CICDPipelineStack", jsii.invoke(self, "addSecurityLintStage", [props]))

    @jsii.member(jsii_name="addSourceAction")
    def add_source_action(
        self,
        *,
        repository_name: builtins.str,
        branch: typing.Optional[builtins.str] = None,
        source_action: typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipelineSource] = None,
    ) -> "CICDPipelineStack":
        '''
        :param repository_name: 
        :param branch: 
        :param source_action: 
        '''
        props = SourceActionProps(
            repository_name=repository_name, branch=branch, source_action=source_action
        )

        return typing.cast("CICDPipelineStack", jsii.invoke(self, "addSourceAction", [props]))

    @jsii.member(jsii_name="addStage")
    def add_stage(
        self,
        *,
        stage: _aws_cdk_ceddda9d.Stage,
        stage_id: builtins.str,
        manual_approvals: typing.Optional[builtins.bool] = None,
    ) -> "CICDPipelineStack":
        '''
        :param stage: 
        :param stage_id: 
        :param manual_approvals: 
        '''
        props = AddApplicationStageProps(
            stage=stage, stage_id=stage_id, manual_approvals=manual_approvals
        )

        return typing.cast("CICDPipelineStack", jsii.invoke(self, "addStage", [props]))

    @jsii.member(jsii_name="addSynthAction")
    def add_synth_action(
        self,
        *,
        additional_install_commands: typing.Optional[typing.Sequence[builtins.str]] = None,
        cdk_version: typing.Optional[builtins.str] = None,
        codeartifact_domain: typing.Optional[builtins.str] = None,
        codeartifact_domain_owner: typing.Optional[builtins.str] = None,
        codeartifact_repository: typing.Optional[builtins.str] = None,
        role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
        synth_action: typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildStep] = None,
    ) -> "CICDPipelineStack":
        '''
        :param additional_install_commands: 
        :param cdk_version: 
        :param codeartifact_domain: 
        :param codeartifact_domain_owner: 
        :param codeartifact_repository: 
        :param role_policy_statements: 
        :param synth_action: 
        '''
        props = SynthActionProps(
            additional_install_commands=additional_install_commands,
            cdk_version=cdk_version,
            codeartifact_domain=codeartifact_domain,
            codeartifact_domain_owner=codeartifact_domain_owner,
            codeartifact_repository=codeartifact_repository,
            role_policy_statements=role_policy_statements,
            synth_action=synth_action,
        )

        return typing.cast("CICDPipelineStack", jsii.invoke(self, "addSynthAction", [props]))

    @jsii.member(jsii_name="addTestStage")
    def add_test_stage(
        self,
        *,
        cloud_assembly_file_set: typing.Optional[_aws_cdk_pipelines_ceddda9d.IFileSetProducer] = None,
        commands: typing.Optional[typing.Sequence[builtins.str]] = None,
        stage_name: typing.Optional[builtins.str] = None,
    ) -> "CICDPipelineStack":
        '''
        :param cloud_assembly_file_set: 
        :param commands: 
        :param stage_name: 
        '''
        props = AddTestStageProps(
            cloud_assembly_file_set=cloud_assembly_file_set,
            commands=commands,
            stage_name=stage_name,
        )

        return typing.cast("CICDPipelineStack", jsii.invoke(self, "addTestStage", [props]))

    @jsii.member(jsii_name="addWave")
    def add_wave(
        self,
        *,
        stage_id: builtins.str,
        stages: typing.Sequence[_aws_cdk_ceddda9d.Stage],
        manual_approvals: typing.Optional[builtins.bool] = None,
    ) -> "CICDPipelineStack":
        '''
        :param stage_id: 
        :param stages: 
        :param manual_approvals: 
        '''
        props = AddApplicationWaveProps(
            stage_id=stage_id, stages=stages, manual_approvals=manual_approvals
        )

        return typing.cast("CICDPipelineStack", jsii.invoke(self, "addWave", [props]))

    @jsii.member(jsii_name="buildPipeline")
    def build_pipeline(
        self,
        *,
        asset_publishing_code_build_defaults: typing.Optional[typing.Union[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions, typing.Dict[builtins.str, typing.Any]]] = None,
        cli_version: typing.Optional[builtins.str] = None,
        code_build_defaults: typing.Optional[typing.Union[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions, typing.Dict[builtins.str, typing.Any]]] = None,
        code_pipeline: typing.Optional[_aws_cdk_aws_codepipeline_ceddda9d.Pipeline] = None,
        docker_credentials: typing.Optional[typing.Sequence[_aws_cdk_pipelines_ceddda9d.DockerCredential]] = None,
        docker_enabled_for_self_mutation: typing.Optional[builtins.bool] = None,
        docker_enabled_for_synth: typing.Optional[builtins.bool] = None,
        publish_assets_in_parallel: typing.Optional[builtins.bool] = None,
        reuse_cross_region_support_stacks: typing.Optional[builtins.bool] = None,
        self_mutation: typing.Optional[builtins.bool] = None,
        self_mutation_code_build_defaults: typing.Optional[typing.Union[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions, typing.Dict[builtins.str, typing.Any]]] = None,
        synth_code_build_defaults: typing.Optional[typing.Union[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> "CICDPipelineStack":
        '''
        :param asset_publishing_code_build_defaults: 
        :param cli_version: 
        :param code_build_defaults: 
        :param code_pipeline: 
        :param docker_credentials: 
        :param docker_enabled_for_self_mutation: 
        :param docker_enabled_for_synth: 
        :param publish_assets_in_parallel: 
        :param reuse_cross_region_support_stacks: 
        :param self_mutation: 
        :param self_mutation_code_build_defaults: 
        :param synth_code_build_defaults: 
        '''
        props = AdditionalPipelineProps(
            asset_publishing_code_build_defaults=asset_publishing_code_build_defaults,
            cli_version=cli_version,
            code_build_defaults=code_build_defaults,
            code_pipeline=code_pipeline,
            docker_credentials=docker_credentials,
            docker_enabled_for_self_mutation=docker_enabled_for_self_mutation,
            docker_enabled_for_synth=docker_enabled_for_synth,
            publish_assets_in_parallel=publish_assets_in_parallel,
            reuse_cross_region_support_stacks=reuse_cross_region_support_stacks,
            self_mutation=self_mutation,
            self_mutation_code_build_defaults=self_mutation_code_build_defaults,
            synth_code_build_defaults=synth_code_build_defaults,
        )

        return typing.cast("CICDPipelineStack", jsii.invoke(self, "buildPipeline", [props]))

    @jsii.member(jsii_name="synth")
    def synth(self) -> "CICDPipelineStack":
        return typing.cast("CICDPipelineStack", jsii.invoke(self, "synth", []))

    @builtins.property
    @jsii.member(jsii_name="cdkLanguage")
    def cdk_language(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "cdkLanguage"))

    @builtins.property
    @jsii.member(jsii_name="config")
    def config(self) -> "Configurator":
        return typing.cast("Configurator", jsii.get(self, "config"))

    @builtins.property
    @jsii.member(jsii_name="environmentId")
    def environment_id(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "environmentId"))

    @builtins.property
    @jsii.member(jsii_name="pipelineId")
    def pipeline_id(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "pipelineId"))

    @builtins.property
    @jsii.member(jsii_name="pipelineName")
    def pipeline_name(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "pipelineName"))

    @builtins.property
    @jsii.member(jsii_name="notificationRule")
    def notification_rule(
        self,
    ) -> typing.Optional[_aws_cdk_aws_codestarnotifications_ceddda9d.NotificationRule]:
        return typing.cast(typing.Optional[_aws_cdk_aws_codestarnotifications_ceddda9d.NotificationRule], jsii.get(self, "notificationRule"))

    @notification_rule.setter
    def notification_rule(
        self,
        value: typing.Optional[_aws_cdk_aws_codestarnotifications_ceddda9d.NotificationRule],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0068433bd751f33d982df797ea7caafaf7cffac6096fcfa31b631eb939dd331b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "notificationRule", value)

    @builtins.property
    @jsii.member(jsii_name="pipeline")
    def pipeline(self) -> typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipeline]:
        return typing.cast(typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipeline], jsii.get(self, "pipeline"))

    @pipeline.setter
    def pipeline(
        self,
        value: typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipeline],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9e242ec0edda32ab650513e5c858717f596009d201ebe6c35d192b13bb37b46e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "pipeline", value)

    @builtins.property
    @jsii.member(jsii_name="pipelineKey")
    def pipeline_key(self) -> typing.Optional[_aws_cdk_aws_kms_ceddda9d.CfnKey]:
        return typing.cast(typing.Optional[_aws_cdk_aws_kms_ceddda9d.CfnKey], jsii.get(self, "pipelineKey"))

    @pipeline_key.setter
    def pipeline_key(
        self,
        value: typing.Optional[_aws_cdk_aws_kms_ceddda9d.CfnKey],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bdd6e87a9d4eea532d3b53339bd619a881413d8b48bab8ceb6116633e65f946d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "pipelineKey", value)

    @builtins.property
    @jsii.member(jsii_name="sourceAction")
    def source_action(
        self,
    ) -> typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipelineSource]:
        return typing.cast(typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipelineSource], jsii.get(self, "sourceAction"))

    @source_action.setter
    def source_action(
        self,
        value: typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipelineSource],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__19397f9a8bd0b90a5f185ea4729b0b19930bbfb902f228f2537c616170569bf6)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sourceAction", value)

    @builtins.property
    @jsii.member(jsii_name="synthAction")
    def synth_action(
        self,
    ) -> typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildStep]:
        return typing.cast(typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildStep], jsii.get(self, "synthAction"))

    @synth_action.setter
    def synth_action(
        self,
        value: typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildStep],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ae2239ce5199560ebc5f2e8f3ab6392af34c4678da2fdeb67265c0f37277507b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "synthAction", value)


@jsii.data_type(
    jsii_type="aws-ddk-core.CICDPipelineStackProps",
    jsii_struct_bases=[BaseStackProps],
    name_mapping={
        "analytics_reporting": "analyticsReporting",
        "cross_region_references": "crossRegionReferences",
        "description": "description",
        "env": "env",
        "permissions_boundary": "permissionsBoundary",
        "stack_name": "stackName",
        "synthesizer": "synthesizer",
        "tags": "tags",
        "termination_protection": "terminationProtection",
        "config": "config",
        "environment_id": "environmentId",
        "permissions_boundary_arn": "permissionsBoundaryArn",
        "cdk_language": "cdkLanguage",
        "pipeline_name": "pipelineName",
    },
)
class CICDPipelineStackProps(BaseStackProps):
    def __init__(
        self,
        *,
        analytics_reporting: typing.Optional[builtins.bool] = None,
        cross_region_references: typing.Optional[builtins.bool] = None,
        description: typing.Optional[builtins.str] = None,
        env: typing.Optional[typing.Union[_aws_cdk_ceddda9d.Environment, typing.Dict[builtins.str, typing.Any]]] = None,
        permissions_boundary: typing.Optional[_aws_cdk_ceddda9d.PermissionsBoundary] = None,
        stack_name: typing.Optional[builtins.str] = None,
        synthesizer: typing.Optional[_aws_cdk_ceddda9d.IStackSynthesizer] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        termination_protection: typing.Optional[builtins.bool] = None,
        config: typing.Optional[typing.Union[builtins.str, typing.Union["Configuration", typing.Dict[builtins.str, typing.Any]]]] = None,
        environment_id: typing.Optional[builtins.str] = None,
        permissions_boundary_arn: typing.Optional[builtins.str] = None,
        cdk_language: typing.Optional[builtins.str] = None,
        pipeline_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param analytics_reporting: Include runtime versioning information in this Stack. Default: ``analyticsReporting`` setting of containing ``App``, or value of 'aws:cdk:version-reporting' context key
        :param cross_region_references: Enable this flag to allow native cross region stack references. Enabling this will create a CloudFormation custom resource in both the producing stack and consuming stack in order to perform the export/import This feature is currently experimental Default: false
        :param description: A description of the stack. Default: - No description.
        :param env: The AWS environment (account/region) where this stack will be deployed. Set the ``region``/``account`` fields of ``env`` to either a concrete value to select the indicated environment (recommended for production stacks), or to the values of environment variables ``CDK_DEFAULT_REGION``/``CDK_DEFAULT_ACCOUNT`` to let the target environment depend on the AWS credentials/configuration that the CDK CLI is executed under (recommended for development stacks). If the ``Stack`` is instantiated inside a ``Stage``, any undefined ``region``/``account`` fields from ``env`` will default to the same field on the encompassing ``Stage``, if configured there. If either ``region`` or ``account`` are not set nor inherited from ``Stage``, the Stack will be considered "*environment-agnostic*"". Environment-agnostic stacks can be deployed to any environment but may not be able to take advantage of all features of the CDK. For example, they will not be able to use environmental context lookups such as ``ec2.Vpc.fromLookup`` and will not automatically translate Service Principals to the right format based on the environment's AWS partition, and other such enhancements. Default: - The environment of the containing ``Stage`` if available, otherwise create the stack will be environment-agnostic.
        :param permissions_boundary: Options for applying a permissions boundary to all IAM Roles and Users created within this Stage. Default: - no permissions boundary is applied
        :param stack_name: Name to deploy the stack with. Default: - Derived from construct path.
        :param synthesizer: Synthesis method to use while deploying this stack. The Stack Synthesizer controls aspects of synthesis and deployment, like how assets are referenced and what IAM roles to use. For more information, see the README of the main CDK package. If not specified, the ``defaultStackSynthesizer`` from ``App`` will be used. If that is not specified, ``DefaultStackSynthesizer`` is used if ``@aws-cdk/core:newStyleStackSynthesis`` is set to ``true`` or the CDK major version is v2. In CDK v1 ``LegacyStackSynthesizer`` is the default if no other synthesizer is specified. Default: - The synthesizer specified on ``App``, or ``DefaultStackSynthesizer`` otherwise.
        :param tags: Stack tags that will be applied to all the taggable resources and the stack itself. Default: {}
        :param termination_protection: Whether to enable termination protection for this stack. Default: false
        :param config: 
        :param environment_id: 
        :param permissions_boundary_arn: 
        :param cdk_language: 
        :param pipeline_name: 
        '''
        if isinstance(env, dict):
            env = _aws_cdk_ceddda9d.Environment(**env)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a92abb1f3b57ec36ef721160ab799be2851ede5d3e872162fc75be713f4d3293)
            check_type(argname="argument analytics_reporting", value=analytics_reporting, expected_type=type_hints["analytics_reporting"])
            check_type(argname="argument cross_region_references", value=cross_region_references, expected_type=type_hints["cross_region_references"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument env", value=env, expected_type=type_hints["env"])
            check_type(argname="argument permissions_boundary", value=permissions_boundary, expected_type=type_hints["permissions_boundary"])
            check_type(argname="argument stack_name", value=stack_name, expected_type=type_hints["stack_name"])
            check_type(argname="argument synthesizer", value=synthesizer, expected_type=type_hints["synthesizer"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument termination_protection", value=termination_protection, expected_type=type_hints["termination_protection"])
            check_type(argname="argument config", value=config, expected_type=type_hints["config"])
            check_type(argname="argument environment_id", value=environment_id, expected_type=type_hints["environment_id"])
            check_type(argname="argument permissions_boundary_arn", value=permissions_boundary_arn, expected_type=type_hints["permissions_boundary_arn"])
            check_type(argname="argument cdk_language", value=cdk_language, expected_type=type_hints["cdk_language"])
            check_type(argname="argument pipeline_name", value=pipeline_name, expected_type=type_hints["pipeline_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if analytics_reporting is not None:
            self._values["analytics_reporting"] = analytics_reporting
        if cross_region_references is not None:
            self._values["cross_region_references"] = cross_region_references
        if description is not None:
            self._values["description"] = description
        if env is not None:
            self._values["env"] = env
        if permissions_boundary is not None:
            self._values["permissions_boundary"] = permissions_boundary
        if stack_name is not None:
            self._values["stack_name"] = stack_name
        if synthesizer is not None:
            self._values["synthesizer"] = synthesizer
        if tags is not None:
            self._values["tags"] = tags
        if termination_protection is not None:
            self._values["termination_protection"] = termination_protection
        if config is not None:
            self._values["config"] = config
        if environment_id is not None:
            self._values["environment_id"] = environment_id
        if permissions_boundary_arn is not None:
            self._values["permissions_boundary_arn"] = permissions_boundary_arn
        if cdk_language is not None:
            self._values["cdk_language"] = cdk_language
        if pipeline_name is not None:
            self._values["pipeline_name"] = pipeline_name

    @builtins.property
    def analytics_reporting(self) -> typing.Optional[builtins.bool]:
        '''Include runtime versioning information in this Stack.

        :default:

        ``analyticsReporting`` setting of containing ``App``, or value of
        'aws:cdk:version-reporting' context key
        '''
        result = self._values.get("analytics_reporting")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def cross_region_references(self) -> typing.Optional[builtins.bool]:
        '''Enable this flag to allow native cross region stack references.

        Enabling this will create a CloudFormation custom resource
        in both the producing stack and consuming stack in order to perform the export/import

        This feature is currently experimental

        :default: false
        '''
        result = self._values.get("cross_region_references")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A description of the stack.

        :default: - No description.
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def env(self) -> typing.Optional[_aws_cdk_ceddda9d.Environment]:
        '''The AWS environment (account/region) where this stack will be deployed.

        Set the ``region``/``account`` fields of ``env`` to either a concrete value to
        select the indicated environment (recommended for production stacks), or to
        the values of environment variables
        ``CDK_DEFAULT_REGION``/``CDK_DEFAULT_ACCOUNT`` to let the target environment
        depend on the AWS credentials/configuration that the CDK CLI is executed
        under (recommended for development stacks).

        If the ``Stack`` is instantiated inside a ``Stage``, any undefined
        ``region``/``account`` fields from ``env`` will default to the same field on the
        encompassing ``Stage``, if configured there.

        If either ``region`` or ``account`` are not set nor inherited from ``Stage``, the
        Stack will be considered "*environment-agnostic*"". Environment-agnostic
        stacks can be deployed to any environment but may not be able to take
        advantage of all features of the CDK. For example, they will not be able to
        use environmental context lookups such as ``ec2.Vpc.fromLookup`` and will not
        automatically translate Service Principals to the right format based on the
        environment's AWS partition, and other such enhancements.

        :default:

        - The environment of the containing ``Stage`` if available,
        otherwise create the stack will be environment-agnostic.

        Example::

            // Use a concrete account and region to deploy this stack to:
            // `.account` and `.region` will simply return these values.
            new Stack(app, 'Stack1', {
              env: {
                account: '123456789012',
                region: 'us-east-1'
              },
            });
            
            // Use the CLI's current credentials to determine the target environment:
            // `.account` and `.region` will reflect the account+region the CLI
            // is configured to use (based on the user CLI credentials)
            new Stack(app, 'Stack2', {
              env: {
                account: process.env.CDK_DEFAULT_ACCOUNT,
                region: process.env.CDK_DEFAULT_REGION
              },
            });
            
            // Define multiple stacks stage associated with an environment
            const myStage = new Stage(app, 'MyStage', {
              env: {
                account: '123456789012',
                region: 'us-east-1'
              }
            });
            
            // both of these stacks will use the stage's account/region:
            // `.account` and `.region` will resolve to the concrete values as above
            new MyStack(myStage, 'Stack1');
            new YourStack(myStage, 'Stack2');
            
            // Define an environment-agnostic stack:
            // `.account` and `.region` will resolve to `{ "Ref": "AWS::AccountId" }` and `{ "Ref": "AWS::Region" }` respectively.
            // which will only resolve to actual values by CloudFormation during deployment.
            new MyStack(app, 'Stack1');
        '''
        result = self._values.get("env")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Environment], result)

    @builtins.property
    def permissions_boundary(
        self,
    ) -> typing.Optional[_aws_cdk_ceddda9d.PermissionsBoundary]:
        '''Options for applying a permissions boundary to all IAM Roles and Users created within this Stage.

        :default: - no permissions boundary is applied
        '''
        result = self._values.get("permissions_boundary")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.PermissionsBoundary], result)

    @builtins.property
    def stack_name(self) -> typing.Optional[builtins.str]:
        '''Name to deploy the stack with.

        :default: - Derived from construct path.
        '''
        result = self._values.get("stack_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def synthesizer(self) -> typing.Optional[_aws_cdk_ceddda9d.IStackSynthesizer]:
        '''Synthesis method to use while deploying this stack.

        The Stack Synthesizer controls aspects of synthesis and deployment,
        like how assets are referenced and what IAM roles to use. For more
        information, see the README of the main CDK package.

        If not specified, the ``defaultStackSynthesizer`` from ``App`` will be used.
        If that is not specified, ``DefaultStackSynthesizer`` is used if
        ``@aws-cdk/core:newStyleStackSynthesis`` is set to ``true`` or the CDK major
        version is v2. In CDK v1 ``LegacyStackSynthesizer`` is the default if no
        other synthesizer is specified.

        :default: - The synthesizer specified on ``App``, or ``DefaultStackSynthesizer`` otherwise.
        '''
        result = self._values.get("synthesizer")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.IStackSynthesizer], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        '''Stack tags that will be applied to all the taggable resources and the stack itself.

        :default: {}
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    @builtins.property
    def termination_protection(self) -> typing.Optional[builtins.bool]:
        '''Whether to enable termination protection for this stack.

        :default: false
        '''
        result = self._values.get("termination_protection")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def config(self) -> typing.Optional[typing.Union[builtins.str, "Configuration"]]:
        result = self._values.get("config")
        return typing.cast(typing.Optional[typing.Union[builtins.str, "Configuration"]], result)

    @builtins.property
    def environment_id(self) -> typing.Optional[builtins.str]:
        result = self._values.get("environment_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def permissions_boundary_arn(self) -> typing.Optional[builtins.str]:
        result = self._values.get("permissions_boundary_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def cdk_language(self) -> typing.Optional[builtins.str]:
        result = self._values.get("cdk_language")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def pipeline_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("pipeline_name")
        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 "CICDPipelineStackProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.CodeArtifactPublishActionProps",
    jsii_struct_bases=[],
    name_mapping={
        "account": "account",
        "codeartifact_domain": "codeartifactDomain",
        "codeartifact_domain_owner": "codeartifactDomainOwner",
        "codeartifact_repository": "codeartifactRepository",
        "partition": "partition",
        "region": "region",
        "code_pipeline_source": "codePipelineSource",
        "role_policy_statements": "rolePolicyStatements",
    },
)
class CodeArtifactPublishActionProps:
    def __init__(
        self,
        *,
        account: builtins.str,
        codeartifact_domain: builtins.str,
        codeartifact_domain_owner: builtins.str,
        codeartifact_repository: builtins.str,
        partition: builtins.str,
        region: builtins.str,
        code_pipeline_source: typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipelineSource] = None,
        role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    ) -> None:
        '''
        :param account: 
        :param codeartifact_domain: 
        :param codeartifact_domain_owner: 
        :param codeartifact_repository: 
        :param partition: 
        :param region: 
        :param code_pipeline_source: 
        :param role_policy_statements: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c35f21eb6e1a4595459d5a4102a340db464f6d6da23770e16d40eca5d3e00623)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument codeartifact_domain", value=codeartifact_domain, expected_type=type_hints["codeartifact_domain"])
            check_type(argname="argument codeartifact_domain_owner", value=codeartifact_domain_owner, expected_type=type_hints["codeartifact_domain_owner"])
            check_type(argname="argument codeartifact_repository", value=codeartifact_repository, expected_type=type_hints["codeartifact_repository"])
            check_type(argname="argument partition", value=partition, expected_type=type_hints["partition"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument code_pipeline_source", value=code_pipeline_source, expected_type=type_hints["code_pipeline_source"])
            check_type(argname="argument role_policy_statements", value=role_policy_statements, expected_type=type_hints["role_policy_statements"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "account": account,
            "codeartifact_domain": codeartifact_domain,
            "codeartifact_domain_owner": codeartifact_domain_owner,
            "codeartifact_repository": codeartifact_repository,
            "partition": partition,
            "region": region,
        }
        if code_pipeline_source is not None:
            self._values["code_pipeline_source"] = code_pipeline_source
        if role_policy_statements is not None:
            self._values["role_policy_statements"] = role_policy_statements

    @builtins.property
    def account(self) -> builtins.str:
        result = self._values.get("account")
        assert result is not None, "Required property 'account' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def codeartifact_domain(self) -> builtins.str:
        result = self._values.get("codeartifact_domain")
        assert result is not None, "Required property 'codeartifact_domain' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def codeartifact_domain_owner(self) -> builtins.str:
        result = self._values.get("codeartifact_domain_owner")
        assert result is not None, "Required property 'codeartifact_domain_owner' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def codeartifact_repository(self) -> builtins.str:
        result = self._values.get("codeartifact_repository")
        assert result is not None, "Required property 'codeartifact_repository' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def partition(self) -> builtins.str:
        result = self._values.get("partition")
        assert result is not None, "Required property 'partition' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def region(self) -> builtins.str:
        result = self._values.get("region")
        assert result is not None, "Required property 'region' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def code_pipeline_source(
        self,
    ) -> typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipelineSource]:
        result = self._values.get("code_pipeline_source")
        return typing.cast(typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipelineSource], result)

    @builtins.property
    def role_policy_statements(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]]:
        result = self._values.get("role_policy_statements")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]], 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 "CodeArtifactPublishActionProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.CodeCommitSourceActionProps",
    jsii_struct_bases=[],
    name_mapping={
        "branch": "branch",
        "repository_name": "repositoryName",
        "props": "props",
    },
)
class CodeCommitSourceActionProps:
    def __init__(
        self,
        *,
        branch: builtins.str,
        repository_name: builtins.str,
        props: typing.Optional[typing.Union[_aws_cdk_pipelines_ceddda9d.ConnectionSourceOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param branch: 
        :param repository_name: 
        :param props: 
        '''
        if isinstance(props, dict):
            props = _aws_cdk_pipelines_ceddda9d.ConnectionSourceOptions(**props)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d8379be0808b59cd840396438fecd2826772ffc3dbcfeaf5175ccf01b988d69b)
            check_type(argname="argument branch", value=branch, expected_type=type_hints["branch"])
            check_type(argname="argument repository_name", value=repository_name, expected_type=type_hints["repository_name"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "branch": branch,
            "repository_name": repository_name,
        }
        if props is not None:
            self._values["props"] = props

    @builtins.property
    def branch(self) -> builtins.str:
        result = self._values.get("branch")
        assert result is not None, "Required property 'branch' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def repository_name(self) -> builtins.str:
        result = self._values.get("repository_name")
        assert result is not None, "Required property 'repository_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def props(
        self,
    ) -> typing.Optional[_aws_cdk_pipelines_ceddda9d.ConnectionSourceOptions]:
        result = self._values.get("props")
        return typing.cast(typing.Optional[_aws_cdk_pipelines_ceddda9d.ConnectionSourceOptions], 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 "CodeCommitSourceActionProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.Configuration",
    jsii_struct_bases=[],
    name_mapping={
        "environments": "environments",
        "account": "account",
        "bootstrap": "bootstrap",
        "ddk_bootstrap_config_key": "ddkBootstrapConfigKey",
        "region": "region",
        "tags": "tags",
    },
)
class Configuration:
    def __init__(
        self,
        *,
        environments: typing.Mapping[builtins.str, typing.Union["EnvironmentConfiguration", typing.Dict[builtins.str, typing.Any]]],
        account: typing.Optional[builtins.str] = None,
        bootstrap: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        ddk_bootstrap_config_key: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    ) -> None:
        '''
        :param environments: 
        :param account: 
        :param bootstrap: 
        :param ddk_bootstrap_config_key: 
        :param region: 
        :param tags: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__daeed9e6cb5e50c39b922933d297c173f25183423bf700dfd9f8b0fe3765c923)
            check_type(argname="argument environments", value=environments, expected_type=type_hints["environments"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument bootstrap", value=bootstrap, expected_type=type_hints["bootstrap"])
            check_type(argname="argument ddk_bootstrap_config_key", value=ddk_bootstrap_config_key, expected_type=type_hints["ddk_bootstrap_config_key"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "environments": environments,
        }
        if account is not None:
            self._values["account"] = account
        if bootstrap is not None:
            self._values["bootstrap"] = bootstrap
        if ddk_bootstrap_config_key is not None:
            self._values["ddk_bootstrap_config_key"] = ddk_bootstrap_config_key
        if region is not None:
            self._values["region"] = region
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def environments(self) -> typing.Mapping[builtins.str, "EnvironmentConfiguration"]:
        result = self._values.get("environments")
        assert result is not None, "Required property 'environments' is missing"
        return typing.cast(typing.Mapping[builtins.str, "EnvironmentConfiguration"], result)

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def bootstrap(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        result = self._values.get("bootstrap")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    @builtins.property
    def ddk_bootstrap_config_key(self) -> typing.Optional[builtins.str]:
        result = self._values.get("ddk_bootstrap_config_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "Configuration(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class Configurator(metaclass=jsii.JSIIMeta, jsii_type="aws-ddk-core.Configurator"):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        config: typing.Union[builtins.str, typing.Union[Configuration, typing.Dict[builtins.str, typing.Any]]],
        environment_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param config: -
        :param environment_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__83dd06108e5a02547d07299060f92123340b3d7ec7e9e6f36a8e28ce02b22a22)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument config", value=config, expected_type=type_hints["config"])
            check_type(argname="argument environment_id", value=environment_id, expected_type=type_hints["environment_id"])
        jsii.create(self.__class__, self, [scope, config, environment_id])

    @jsii.member(jsii_name="getEnvConfig")
    @builtins.classmethod
    def get_env_config(
        cls,
        *,
        config_path: builtins.str,
        environment_id: builtins.str,
    ) -> "EnvironmentConfiguration":
        '''
        :param config_path: 
        :param environment_id: 
        '''
        props = GetEnvConfigProps(
            config_path=config_path, environment_id=environment_id
        )

        return typing.cast("EnvironmentConfiguration", jsii.sinvoke(cls, "getEnvConfig", [props]))

    @jsii.member(jsii_name="getEnvironment")
    @builtins.classmethod
    def get_environment(
        cls,
        *,
        config_path: builtins.str,
        environment_id: typing.Optional[builtins.str] = None,
    ) -> "EnvironmentResult":
        '''
        :param config_path: 
        :param environment_id: 
        '''
        props = GetEnvironmentProps(
            config_path=config_path, environment_id=environment_id
        )

        return typing.cast("EnvironmentResult", jsii.sinvoke(cls, "getEnvironment", [props]))

    @jsii.member(jsii_name="getTags")
    @builtins.classmethod
    def get_tags(
        cls,
        *,
        config_path: builtins.str,
        environment_id: typing.Optional[builtins.str] = None,
    ) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :param config_path: 
        :param environment_id: 
        '''
        props = GetTagsProps(config_path=config_path, environment_id=environment_id)

        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.sinvoke(cls, "getTags", [props]))

    @jsii.member(jsii_name="getConfigAttribute")
    def get_config_attribute(self, attribute: builtins.str) -> typing.Any:
        '''
        :param attribute: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ce369044fa737e8a329b15db41cbef0ecf3e52cea663d9bd55b6edfe486a7705)
            check_type(argname="argument attribute", value=attribute, expected_type=type_hints["attribute"])
        return typing.cast(typing.Any, jsii.invoke(self, "getConfigAttribute", [attribute]))

    @jsii.member(jsii_name="tagConstruct")
    def tag_construct(
        self,
        scope: _constructs_77d1e7e8.Construct,
        tags: typing.Mapping[builtins.str, builtins.str],
    ) -> None:
        '''
        :param scope: -
        :param tags: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5ebebaeeabeb2e14afe10bb65476a72e653389f44163949f819c5b260fc48e7c)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        return typing.cast(None, jsii.invoke(self, "tagConstruct", [scope, tags]))

    @builtins.property
    @jsii.member(jsii_name="config")
    def config(self) -> Configuration:
        return typing.cast(Configuration, jsii.get(self, "config"))

    @builtins.property
    @jsii.member(jsii_name="environmentId")
    def environment_id(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "environmentId"))


@jsii.data_type(
    jsii_type="aws-ddk-core.CreateStateMachineResult",
    jsii_struct_bases=[],
    name_mapping={
        "event_pattern": "eventPattern",
        "state_machine": "stateMachine",
        "targets": "targets",
    },
)
class CreateStateMachineResult:
    def __init__(
        self,
        *,
        event_pattern: typing.Union[_aws_cdk_aws_events_ceddda9d.EventPattern, typing.Dict[builtins.str, typing.Any]],
        state_machine: _aws_cdk_aws_stepfunctions_ceddda9d.StateMachine,
        targets: typing.Sequence[_aws_cdk_aws_events_ceddda9d.IRuleTarget],
    ) -> None:
        '''
        :param event_pattern: 
        :param state_machine: 
        :param targets: 
        '''
        if isinstance(event_pattern, dict):
            event_pattern = _aws_cdk_aws_events_ceddda9d.EventPattern(**event_pattern)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a42d01fb82a6fe17fa9b9b89a21fb52b88b8267a8d48f866ab150cb834952324)
            check_type(argname="argument event_pattern", value=event_pattern, expected_type=type_hints["event_pattern"])
            check_type(argname="argument state_machine", value=state_machine, expected_type=type_hints["state_machine"])
            check_type(argname="argument targets", value=targets, expected_type=type_hints["targets"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "event_pattern": event_pattern,
            "state_machine": state_machine,
            "targets": targets,
        }

    @builtins.property
    def event_pattern(self) -> _aws_cdk_aws_events_ceddda9d.EventPattern:
        result = self._values.get("event_pattern")
        assert result is not None, "Required property 'event_pattern' is missing"
        return typing.cast(_aws_cdk_aws_events_ceddda9d.EventPattern, result)

    @builtins.property
    def state_machine(self) -> _aws_cdk_aws_stepfunctions_ceddda9d.StateMachine:
        result = self._values.get("state_machine")
        assert result is not None, "Required property 'state_machine' is missing"
        return typing.cast(_aws_cdk_aws_stepfunctions_ceddda9d.StateMachine, result)

    @builtins.property
    def targets(self) -> typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]:
        result = self._values.get("targets")
        assert result is not None, "Required property 'targets' is missing"
        return typing.cast(typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget], 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 "CreateStateMachineResult(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class DataPipeline(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-ddk-core.DataPipeline",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__020d69ac62c8be050bbf68165b37eefae84c4185726ff175a8444e0c59df78df)
            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 = DataPipelineProps(description=description, name=name)

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="addNotifications")
    def add_notifications(
        self,
        notifications_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
    ) -> "DataPipeline":
        '''
        :param notifications_topic: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0261b3bfb9d75b19f131b94fdac46b066b26e0543adf83caf2f9ff8436e7fc80)
            check_type(argname="argument notifications_topic", value=notifications_topic, expected_type=type_hints["notifications_topic"])
        return typing.cast("DataPipeline", jsii.invoke(self, "addNotifications", [notifications_topic]))

    @jsii.member(jsii_name="addRule")
    def add_rule(
        self,
        *,
        event_pattern: typing.Optional[typing.Union[_aws_cdk_aws_events_ceddda9d.EventPattern, typing.Dict[builtins.str, typing.Any]]] = None,
        event_targets: typing.Optional[typing.Sequence[_aws_cdk_aws_events_ceddda9d.IRuleTarget]] = None,
        id: typing.Optional[builtins.str] = None,
        override_rule: typing.Optional[_aws_cdk_aws_events_ceddda9d.IRule] = None,
        rule_name: typing.Optional[builtins.str] = None,
        schedule: typing.Optional[_aws_cdk_aws_events_ceddda9d.Schedule] = None,
    ) -> "DataPipeline":
        '''
        :param event_pattern: 
        :param event_targets: 
        :param id: 
        :param override_rule: 
        :param rule_name: 
        :param schedule: 
        '''
        props = AddRuleProps(
            event_pattern=event_pattern,
            event_targets=event_targets,
            id=id,
            override_rule=override_rule,
            rule_name=rule_name,
            schedule=schedule,
        )

        return typing.cast("DataPipeline", jsii.invoke(self, "addRule", [props]))

    @jsii.member(jsii_name="addStage")
    def add_stage(
        self,
        *,
        stage: "Stage",
        override_rule: typing.Optional[_aws_cdk_aws_events_ceddda9d.IRule] = None,
        rule_name: typing.Optional[builtins.str] = None,
        schedule: typing.Optional[_aws_cdk_aws_events_ceddda9d.Schedule] = None,
        skip_rule: typing.Optional[builtins.bool] = None,
    ) -> "DataPipeline":
        '''
        :param stage: 
        :param override_rule: 
        :param rule_name: 
        :param schedule: 
        :param skip_rule: 
        '''
        props = AddStageProps(
            stage=stage,
            override_rule=override_rule,
            rule_name=rule_name,
            schedule=schedule,
            skip_rule=skip_rule,
        )

        return typing.cast("DataPipeline", jsii.invoke(self, "addStage", [props]))

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "name"))


@jsii.data_type(
    jsii_type="aws-ddk-core.DataPipelineProps",
    jsii_struct_bases=[],
    name_mapping={"description": "description", "name": "name"},
)
class DataPipelineProps:
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__946287dcda6fcab40d64fc9e8f72a5917de6ace9c417f850f53a1418c864067d)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if name is not None:
            self._values["name"] = name

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("name")
        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 "DataPipelineProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.DeliveryStreamProps",
    jsii_struct_bases=[],
    name_mapping={
        "delivery_stream_name": "deliveryStreamName",
        "destinations": "destinations",
        "encryption": "encryption",
        "encryption_key": "encryptionKey",
        "role": "role",
        "source_stream": "sourceStream",
    },
)
class DeliveryStreamProps:
    def __init__(
        self,
        *,
        delivery_stream_name: typing.Optional[builtins.str] = None,
        destinations: typing.Optional[typing.Sequence[_aws_cdk_aws_kinesisfirehose_alpha_30daaf29.IDestination]] = None,
        encryption: typing.Optional[_aws_cdk_aws_kinesisfirehose_alpha_30daaf29.StreamEncryption] = None,
        encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey] = None,
        role: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole] = None,
        source_stream: typing.Optional[_aws_cdk_aws_kinesis_ceddda9d.IStream] = None,
    ) -> None:
        '''
        :param delivery_stream_name: 
        :param destinations: 
        :param encryption: 
        :param encryption_key: 
        :param role: 
        :param source_stream: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ef7997fe1d9215e0814459fdbbb95740e62a7f0437cd0df0dcd43ac255b163e4)
            check_type(argname="argument delivery_stream_name", value=delivery_stream_name, expected_type=type_hints["delivery_stream_name"])
            check_type(argname="argument destinations", value=destinations, expected_type=type_hints["destinations"])
            check_type(argname="argument encryption", value=encryption, expected_type=type_hints["encryption"])
            check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
            check_type(argname="argument role", value=role, expected_type=type_hints["role"])
            check_type(argname="argument source_stream", value=source_stream, expected_type=type_hints["source_stream"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if delivery_stream_name is not None:
            self._values["delivery_stream_name"] = delivery_stream_name
        if destinations is not None:
            self._values["destinations"] = destinations
        if encryption is not None:
            self._values["encryption"] = encryption
        if encryption_key is not None:
            self._values["encryption_key"] = encryption_key
        if role is not None:
            self._values["role"] = role
        if source_stream is not None:
            self._values["source_stream"] = source_stream

    @builtins.property
    def delivery_stream_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("delivery_stream_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def destinations(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_kinesisfirehose_alpha_30daaf29.IDestination]]:
        result = self._values.get("destinations")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_kinesisfirehose_alpha_30daaf29.IDestination]], result)

    @builtins.property
    def encryption(
        self,
    ) -> typing.Optional[_aws_cdk_aws_kinesisfirehose_alpha_30daaf29.StreamEncryption]:
        result = self._values.get("encryption")
        return typing.cast(typing.Optional[_aws_cdk_aws_kinesisfirehose_alpha_30daaf29.StreamEncryption], result)

    @builtins.property
    def encryption_key(self) -> typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey]:
        result = self._values.get("encryption_key")
        return typing.cast(typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey], result)

    @builtins.property
    def role(self) -> typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole]:
        result = self._values.get("role")
        return typing.cast(typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole], result)

    @builtins.property
    def source_stream(self) -> typing.Optional[_aws_cdk_aws_kinesis_ceddda9d.IStream]:
        result = self._values.get("source_stream")
        return typing.cast(typing.Optional[_aws_cdk_aws_kinesis_ceddda9d.IStream], 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 "DeliveryStreamProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.EnvironmentConfiguration",
    jsii_struct_bases=[],
    name_mapping={
        "account": "account",
        "bootstrap": "bootstrap",
        "region": "region",
        "resources": "resources",
        "tags": "tags",
    },
)
class EnvironmentConfiguration:
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        bootstrap: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        region: typing.Optional[builtins.str] = None,
        resources: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    ) -> None:
        '''
        :param account: 
        :param bootstrap: 
        :param region: 
        :param resources: 
        :param tags: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cf306c436463dcb56197f32e9c4793604595ef2ca8f42b2d72de058d5806870c)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument bootstrap", value=bootstrap, expected_type=type_hints["bootstrap"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument resources", value=resources, expected_type=type_hints["resources"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if bootstrap is not None:
            self._values["bootstrap"] = bootstrap
        if region is not None:
            self._values["region"] = region
        if resources is not None:
            self._values["resources"] = resources
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def bootstrap(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        result = self._values.get("bootstrap")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def resources(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        result = self._values.get("resources")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "EnvironmentConfiguration(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.EnvironmentResult",
    jsii_struct_bases=[],
    name_mapping={"account": "account", "region": "region"},
)
class EnvironmentResult:
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param account: 
        :param region: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c2515674b45134976862352edd7f3a4f56dddd10e860df69a14d633b55dfe768)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        result = self._values.get("region")
        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 "EnvironmentResult(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.GetEnvConfigProps",
    jsii_struct_bases=[],
    name_mapping={"config_path": "configPath", "environment_id": "environmentId"},
)
class GetEnvConfigProps:
    def __init__(
        self,
        *,
        config_path: builtins.str,
        environment_id: builtins.str,
    ) -> None:
        '''
        :param config_path: 
        :param environment_id: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__392d4bf9e0a3416c4cbfe2cfcca884cc2b98f96b99a23a03e386497b6cfd2fef)
            check_type(argname="argument config_path", value=config_path, expected_type=type_hints["config_path"])
            check_type(argname="argument environment_id", value=environment_id, expected_type=type_hints["environment_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "config_path": config_path,
            "environment_id": environment_id,
        }

    @builtins.property
    def config_path(self) -> builtins.str:
        result = self._values.get("config_path")
        assert result is not None, "Required property 'config_path' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def environment_id(self) -> builtins.str:
        result = self._values.get("environment_id")
        assert result is not None, "Required property 'environment_id' 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 "GetEnvConfigProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.GetEnvironmentProps",
    jsii_struct_bases=[],
    name_mapping={"config_path": "configPath", "environment_id": "environmentId"},
)
class GetEnvironmentProps:
    def __init__(
        self,
        *,
        config_path: builtins.str,
        environment_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param config_path: 
        :param environment_id: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f1d1864ebb63e794b66b601804d8a186ccc2fe70e5c1aeea9def8ecd1ab83dde)
            check_type(argname="argument config_path", value=config_path, expected_type=type_hints["config_path"])
            check_type(argname="argument environment_id", value=environment_id, expected_type=type_hints["environment_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "config_path": config_path,
        }
        if environment_id is not None:
            self._values["environment_id"] = environment_id

    @builtins.property
    def config_path(self) -> builtins.str:
        result = self._values.get("config_path")
        assert result is not None, "Required property 'config_path' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def environment_id(self) -> typing.Optional[builtins.str]:
        result = self._values.get("environment_id")
        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 "GetEnvironmentProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.GetSynthActionProps",
    jsii_struct_bases=[],
    name_mapping={
        "account": "account",
        "additional_install_commands": "additionalInstallCommands",
        "cdk_version": "cdkVersion",
        "codeartifact_domain": "codeartifactDomain",
        "codeartifact_domain_owner": "codeartifactDomainOwner",
        "codeartifact_repository": "codeartifactRepository",
        "code_pipeline_source": "codePipelineSource",
        "partition": "partition",
        "region": "region",
        "role_policy_statements": "rolePolicyStatements",
    },
)
class GetSynthActionProps:
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        additional_install_commands: typing.Optional[typing.Sequence[builtins.str]] = None,
        cdk_version: typing.Optional[builtins.str] = None,
        codeartifact_domain: typing.Optional[builtins.str] = None,
        codeartifact_domain_owner: typing.Optional[builtins.str] = None,
        codeartifact_repository: typing.Optional[builtins.str] = None,
        code_pipeline_source: typing.Optional[_aws_cdk_pipelines_ceddda9d.IFileSetProducer] = None,
        partition: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    ) -> None:
        '''
        :param account: 
        :param additional_install_commands: 
        :param cdk_version: 
        :param codeartifact_domain: 
        :param codeartifact_domain_owner: 
        :param codeartifact_repository: 
        :param code_pipeline_source: 
        :param partition: 
        :param region: 
        :param role_policy_statements: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b411e230303f93f36fe42f88f3ae59e51d4746a608fa21c8fe560bb5fe18a352)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument additional_install_commands", value=additional_install_commands, expected_type=type_hints["additional_install_commands"])
            check_type(argname="argument cdk_version", value=cdk_version, expected_type=type_hints["cdk_version"])
            check_type(argname="argument codeartifact_domain", value=codeartifact_domain, expected_type=type_hints["codeartifact_domain"])
            check_type(argname="argument codeartifact_domain_owner", value=codeartifact_domain_owner, expected_type=type_hints["codeartifact_domain_owner"])
            check_type(argname="argument codeartifact_repository", value=codeartifact_repository, expected_type=type_hints["codeartifact_repository"])
            check_type(argname="argument code_pipeline_source", value=code_pipeline_source, expected_type=type_hints["code_pipeline_source"])
            check_type(argname="argument partition", value=partition, expected_type=type_hints["partition"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument role_policy_statements", value=role_policy_statements, expected_type=type_hints["role_policy_statements"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if additional_install_commands is not None:
            self._values["additional_install_commands"] = additional_install_commands
        if cdk_version is not None:
            self._values["cdk_version"] = cdk_version
        if codeartifact_domain is not None:
            self._values["codeartifact_domain"] = codeartifact_domain
        if codeartifact_domain_owner is not None:
            self._values["codeartifact_domain_owner"] = codeartifact_domain_owner
        if codeartifact_repository is not None:
            self._values["codeartifact_repository"] = codeartifact_repository
        if code_pipeline_source is not None:
            self._values["code_pipeline_source"] = code_pipeline_source
        if partition is not None:
            self._values["partition"] = partition
        if region is not None:
            self._values["region"] = region
        if role_policy_statements is not None:
            self._values["role_policy_statements"] = role_policy_statements

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def additional_install_commands(self) -> typing.Optional[typing.List[builtins.str]]:
        result = self._values.get("additional_install_commands")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def cdk_version(self) -> typing.Optional[builtins.str]:
        result = self._values.get("cdk_version")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def codeartifact_domain(self) -> typing.Optional[builtins.str]:
        result = self._values.get("codeartifact_domain")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def codeartifact_domain_owner(self) -> typing.Optional[builtins.str]:
        result = self._values.get("codeartifact_domain_owner")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def codeartifact_repository(self) -> typing.Optional[builtins.str]:
        result = self._values.get("codeartifact_repository")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def code_pipeline_source(
        self,
    ) -> typing.Optional[_aws_cdk_pipelines_ceddda9d.IFileSetProducer]:
        result = self._values.get("code_pipeline_source")
        return typing.cast(typing.Optional[_aws_cdk_pipelines_ceddda9d.IFileSetProducer], result)

    @builtins.property
    def partition(self) -> typing.Optional[builtins.str]:
        result = self._values.get("partition")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def role_policy_statements(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]]:
        result = self._values.get("role_policy_statements")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]], 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 "GetSynthActionProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.GetTagsProps",
    jsii_struct_bases=[],
    name_mapping={"config_path": "configPath", "environment_id": "environmentId"},
)
class GetTagsProps:
    def __init__(
        self,
        *,
        config_path: builtins.str,
        environment_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param config_path: 
        :param environment_id: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f80411a398b3a95cafcc083fedf809e35c9f9d3c872682fa20c2c416251da930)
            check_type(argname="argument config_path", value=config_path, expected_type=type_hints["config_path"])
            check_type(argname="argument environment_id", value=environment_id, expected_type=type_hints["environment_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "config_path": config_path,
        }
        if environment_id is not None:
            self._values["environment_id"] = environment_id

    @builtins.property
    def config_path(self) -> builtins.str:
        result = self._values.get("config_path")
        assert result is not None, "Required property 'config_path' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def environment_id(self) -> typing.Optional[builtins.str]:
        result = self._values.get("environment_id")
        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 "GetTagsProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class GlueFactory(metaclass=jsii.JSIIMeta, jsii_type="aws-ddk-core.GlueFactory"):
    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="job")
    @builtins.classmethod
    def job(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        executable: _aws_cdk_aws_glue_alpha_ce674d29.JobExecutable,
        connections: typing.Optional[typing.Sequence[_aws_cdk_aws_glue_alpha_ce674d29.IConnection]] = None,
        continuous_logging: typing.Optional[typing.Union[_aws_cdk_aws_glue_alpha_ce674d29.ContinuousLoggingProps, typing.Dict[builtins.str, typing.Any]]] = None,
        default_arguments: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        description: typing.Optional[builtins.str] = None,
        enable_profiling_metrics: typing.Optional[builtins.bool] = None,
        job_name: typing.Optional[builtins.str] = None,
        max_capacity: typing.Optional[jsii.Number] = None,
        max_concurrent_runs: typing.Optional[jsii.Number] = None,
        max_retries: typing.Optional[jsii.Number] = None,
        notify_delay_after: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        role: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole] = None,
        security_configuration: typing.Optional[_aws_cdk_aws_glue_alpha_ce674d29.ISecurityConfiguration] = None,
        spark_ui: typing.Optional[typing.Union[_aws_cdk_aws_glue_alpha_ce674d29.SparkUIProps, typing.Dict[builtins.str, typing.Any]]] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        worker_count: typing.Optional[jsii.Number] = None,
        worker_type: typing.Optional[_aws_cdk_aws_glue_alpha_ce674d29.WorkerType] = None,
    ) -> _aws_cdk_aws_glue_alpha_ce674d29.Job:
        '''
        :param scope: -
        :param id: -
        :param executable: (experimental) The job's executable properties.
        :param connections: (experimental) The ``Connection``s used for this job. Connections are used to connect to other AWS Service or resources within a VPC. Default: [] - no connections are added to the job
        :param continuous_logging: (experimental) Enables continuous logging with the specified props. Default: - continuous logging is disabled.
        :param default_arguments: (experimental) The default arguments for this job, specified as name-value pairs. Default: - no arguments
        :param description: (experimental) The description of the job. Default: - no value
        :param enable_profiling_metrics: (experimental) Enables the collection of metrics for job profiling. Default: - no profiling metrics emitted.
        :param job_name: (experimental) The name of the job. Default: - a name is automatically generated
        :param max_capacity: (experimental) The number of AWS Glue data processing units (DPUs) that can be allocated when this job runs. Cannot be used for Glue version 2.0 and later - workerType and workerCount should be used instead. Default: - 10 when job type is Apache Spark ETL or streaming, 0.0625 when job type is Python shell
        :param max_concurrent_runs: (experimental) The maximum number of concurrent runs allowed for the job. An error is returned when this threshold is reached. The maximum value you can specify is controlled by a service limit. Default: 1
        :param max_retries: (experimental) The maximum number of times to retry this job after a job run fails. Default: 0
        :param notify_delay_after: (experimental) The number of minutes to wait after a job run starts, before sending a job run delay notification. Default: - no delay notifications
        :param role: (experimental) The IAM role assumed by Glue to run this job. If providing a custom role, it needs to trust the Glue service principal (glue.amazonaws.com) and be granted sufficient permissions. Default: - a role is automatically generated
        :param security_configuration: (experimental) The ``SecurityConfiguration`` to use for this job. Default: - no security configuration.
        :param spark_ui: (experimental) Enables the Spark UI debugging and monitoring with the specified props. Default: - Spark UI debugging and monitoring is disabled.
        :param tags: (experimental) The tags to add to the resources on which the job runs. Default: {} - no tags
        :param timeout: (experimental) The maximum time that a job run can consume resources before it is terminated and enters TIMEOUT status. Default: cdk.Duration.hours(48)
        :param worker_count: (experimental) The number of workers of a defined ``WorkerType`` that are allocated when a job runs. Default: - differs based on specific Glue version/worker type
        :param worker_type: (experimental) The type of predefined worker that is allocated when a job runs. Default: - differs based on specific Glue version
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__de56c47dda07ed1c4eda1133b7152caa819140d8ea5277eaf41f2802c2c16bfd)
            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 = _aws_cdk_aws_glue_alpha_ce674d29.JobProps(
            executable=executable,
            connections=connections,
            continuous_logging=continuous_logging,
            default_arguments=default_arguments,
            description=description,
            enable_profiling_metrics=enable_profiling_metrics,
            job_name=job_name,
            max_capacity=max_capacity,
            max_concurrent_runs=max_concurrent_runs,
            max_retries=max_retries,
            notify_delay_after=notify_delay_after,
            role=role,
            security_configuration=security_configuration,
            spark_ui=spark_ui,
            tags=tags,
            timeout=timeout,
            worker_count=worker_count,
            worker_type=worker_type,
        )

        return typing.cast(_aws_cdk_aws_glue_alpha_ce674d29.Job, jsii.sinvoke(cls, "job", [scope, id, props]))


class KmsFactory(metaclass=jsii.JSIIMeta, jsii_type="aws-ddk-core.KmsFactory"):
    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="key")
    @builtins.classmethod
    def key(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        admins: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.IPrincipal]] = None,
        alias: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        enabled: typing.Optional[builtins.bool] = None,
        enable_key_rotation: typing.Optional[builtins.bool] = None,
        key_spec: typing.Optional[_aws_cdk_aws_kms_ceddda9d.KeySpec] = None,
        key_usage: typing.Optional[_aws_cdk_aws_kms_ceddda9d.KeyUsage] = None,
        pending_window: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        policy: typing.Optional[_aws_cdk_aws_iam_ceddda9d.PolicyDocument] = None,
        removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    ) -> _aws_cdk_aws_kms_ceddda9d.Key:
        '''
        :param scope: -
        :param id: -
        :param admins: A list of principals to add as key administrators to the key policy. Key administrators have permissions to manage the key (e.g., change permissions, revoke), but do not have permissions to use the key in cryptographic operations (e.g., encrypt, decrypt). These principals will be added to the default key policy (if none specified), or to the specified policy (if provided). Default: []
        :param alias: Initial alias to add to the key. More aliases can be added later by calling ``addAlias``. Default: - No alias is added for the key.
        :param description: A description of the key. Use a description that helps your users decide whether the key is appropriate for a particular task. Default: - No description.
        :param enabled: Indicates whether the key is available for use. Default: - Key is enabled.
        :param enable_key_rotation: Indicates whether AWS KMS rotates the key. Default: false
        :param key_spec: The cryptographic configuration of the key. The valid value depends on usage of the key. IMPORTANT: If you change this property of an existing key, the existing key is scheduled for deletion and a new key is created with the specified value. Default: KeySpec.SYMMETRIC_DEFAULT
        :param key_usage: The cryptographic operations for which the key can be used. IMPORTANT: If you change this property of an existing key, the existing key is scheduled for deletion and a new key is created with the specified value. Default: KeyUsage.ENCRYPT_DECRYPT
        :param pending_window: Specifies the number of days in the waiting period before AWS KMS deletes a CMK that has been removed from a CloudFormation stack. When you remove a customer master key (CMK) from a CloudFormation stack, AWS KMS schedules the CMK for deletion and starts the mandatory waiting period. The PendingWindowInDays property determines the length of waiting period. During the waiting period, the key state of CMK is Pending Deletion, which prevents the CMK from being used in cryptographic operations. When the waiting period expires, AWS KMS permanently deletes the CMK. Enter a value between 7 and 30 days. Default: - 30 days
        :param policy: Custom policy document to attach to the KMS key. NOTE - If the ``@aws-cdk/aws-kms:defaultKeyPolicies`` feature flag is set (the default for new projects), this policy will *override* the default key policy and become the only key policy for the key. If the feature flag is not set, this policy will be appended to the default key policy. Default: - A policy document with permissions for the account root to administer the key will be created.
        :param removal_policy: Whether the encryption key should be retained when it is removed from the Stack. This is useful when one wants to retain access to data that was encrypted with a key that is being retired. Default: RemovalPolicy.Retain
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a14864520200528bc5a9369b081737198f4eb3e97462ea981304386c09050813)
            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 = _aws_cdk_aws_kms_ceddda9d.KeyProps(
            admins=admins,
            alias=alias,
            description=description,
            enabled=enabled,
            enable_key_rotation=enable_key_rotation,
            key_spec=key_spec,
            key_usage=key_usage,
            pending_window=pending_window,
            policy=policy,
            removal_policy=removal_policy,
        )

        return typing.cast(_aws_cdk_aws_kms_ceddda9d.Key, jsii.sinvoke(cls, "key", [scope, id, props]))


@jsii.data_type(
    jsii_type="aws-ddk-core.PermissionsBoundaryProps",
    jsii_struct_bases=[],
    name_mapping={
        "environment_id": "environmentId",
        "prefix": "prefix",
        "qualifier": "qualifier",
    },
)
class PermissionsBoundaryProps:
    def __init__(
        self,
        *,
        environment_id: typing.Optional[builtins.str] = None,
        prefix: typing.Optional[builtins.str] = None,
        qualifier: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param environment_id: 
        :param prefix: 
        :param qualifier: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__efd5392745ac5f11de7c7110e4c4c8cc4060becd6944d345396c27f2c82152b4)
            check_type(argname="argument environment_id", value=environment_id, expected_type=type_hints["environment_id"])
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
            check_type(argname="argument qualifier", value=qualifier, expected_type=type_hints["qualifier"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if environment_id is not None:
            self._values["environment_id"] = environment_id
        if prefix is not None:
            self._values["prefix"] = prefix
        if qualifier is not None:
            self._values["qualifier"] = qualifier

    @builtins.property
    def environment_id(self) -> typing.Optional[builtins.str]:
        result = self._values.get("environment_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def prefix(self) -> typing.Optional[builtins.str]:
        result = self._values.get("prefix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def qualifier(self) -> typing.Optional[builtins.str]:
        result = self._values.get("qualifier")
        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 "PermissionsBoundaryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class S3Factory(metaclass=jsii.JSIIMeta, jsii_type="aws-ddk-core.S3Factory"):
    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="bucket")
    @builtins.classmethod
    def bucket(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        access_control: typing.Optional[_aws_cdk_aws_s3_ceddda9d.BucketAccessControl] = None,
        auto_delete_objects: typing.Optional[builtins.bool] = None,
        block_public_access: typing.Optional[_aws_cdk_aws_s3_ceddda9d.BlockPublicAccess] = None,
        bucket_key_enabled: typing.Optional[builtins.bool] = None,
        bucket_name: typing.Optional[builtins.str] = None,
        cors: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_s3_ceddda9d.CorsRule, typing.Dict[builtins.str, typing.Any]]]] = None,
        encryption: typing.Optional[_aws_cdk_aws_s3_ceddda9d.BucketEncryption] = None,
        encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey] = None,
        enforce_ssl: typing.Optional[builtins.bool] = None,
        event_bridge_enabled: typing.Optional[builtins.bool] = None,
        intelligent_tiering_configurations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_s3_ceddda9d.IntelligentTieringConfiguration, typing.Dict[builtins.str, typing.Any]]]] = None,
        inventories: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_s3_ceddda9d.Inventory, typing.Dict[builtins.str, typing.Any]]]] = None,
        lifecycle_rules: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_s3_ceddda9d.LifecycleRule, typing.Dict[builtins.str, typing.Any]]]] = None,
        metrics: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_s3_ceddda9d.BucketMetrics, typing.Dict[builtins.str, typing.Any]]]] = None,
        notifications_handler_role: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole] = None,
        object_lock_default_retention: typing.Optional[_aws_cdk_aws_s3_ceddda9d.ObjectLockRetention] = None,
        object_lock_enabled: typing.Optional[builtins.bool] = None,
        object_ownership: typing.Optional[_aws_cdk_aws_s3_ceddda9d.ObjectOwnership] = None,
        public_read_access: typing.Optional[builtins.bool] = None,
        removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
        server_access_logs_bucket: typing.Optional[_aws_cdk_aws_s3_ceddda9d.IBucket] = None,
        server_access_logs_prefix: typing.Optional[builtins.str] = None,
        transfer_acceleration: typing.Optional[builtins.bool] = None,
        versioned: typing.Optional[builtins.bool] = None,
        website_error_document: typing.Optional[builtins.str] = None,
        website_index_document: typing.Optional[builtins.str] = None,
        website_redirect: typing.Optional[typing.Union[_aws_cdk_aws_s3_ceddda9d.RedirectTarget, typing.Dict[builtins.str, typing.Any]]] = None,
        website_routing_rules: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_s3_ceddda9d.RoutingRule, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> _aws_cdk_aws_s3_ceddda9d.Bucket:
        '''
        :param scope: -
        :param id: -
        :param access_control: Specifies a canned ACL that grants predefined permissions to the bucket. Default: BucketAccessControl.PRIVATE
        :param auto_delete_objects: Whether all objects should be automatically deleted when the bucket is removed from the stack or when the stack is deleted. Requires the ``removalPolicy`` to be set to ``RemovalPolicy.DESTROY``. **Warning** if you have deployed a bucket with ``autoDeleteObjects: true``, switching this to ``false`` in a CDK version *before* ``1.126.0`` will lead to all objects in the bucket being deleted. Be sure to update your bucket resources by deploying with CDK version ``1.126.0`` or later **before** switching this value to ``false``. Default: false
        :param block_public_access: The block public access configuration of this bucket. Default: - CloudFormation defaults will apply. New buckets and objects don't allow public access, but users can modify bucket policies or object permissions to allow public access
        :param bucket_key_enabled: Whether Amazon S3 should use its own intermediary key to generate data keys. Only relevant when using KMS for encryption. - If not enabled, every object GET and PUT will cause an API call to KMS (with the attendant cost implications of that). - If enabled, S3 will use its own time-limited key instead. Only relevant, when Encryption is set to ``BucketEncryption.KMS`` or ``BucketEncryption.KMS_MANAGED``. Default: - false
        :param bucket_name: Physical name of this bucket. Default: - Assigned by CloudFormation (recommended).
        :param cors: The CORS configuration of this bucket. Default: - No CORS configuration.
        :param encryption: The kind of server-side encryption to apply to this bucket. If you choose KMS, you can specify a KMS key via ``encryptionKey``. If encryption key is not specified, a key will automatically be created. Default: - ``Kms`` if ``encryptionKey`` is specified, or ``Unencrypted`` otherwise.
        :param encryption_key: External KMS key to use for bucket encryption. The 'encryption' property must be either not specified or set to "Kms". An error will be emitted if encryption is set to "Unencrypted" or "Managed". Default: - If encryption is set to "Kms" and this property is undefined, a new KMS key will be created and associated with this bucket.
        :param enforce_ssl: Enforces SSL for requests. S3.5 of the AWS Foundational Security Best Practices Regarding S3. Default: false
        :param event_bridge_enabled: Whether this bucket should send notifications to Amazon EventBridge or not. Default: false
        :param intelligent_tiering_configurations: Inteligent Tiering Configurations. Default: No Intelligent Tiiering Configurations.
        :param inventories: The inventory configuration of the bucket. Default: - No inventory configuration
        :param lifecycle_rules: Rules that define how Amazon S3 manages objects during their lifetime. Default: - No lifecycle rules.
        :param metrics: The metrics configuration of this bucket. Default: - No metrics configuration.
        :param notifications_handler_role: The role to be used by the notifications handler. Default: - a new role will be created.
        :param object_lock_default_retention: The default retention mode and rules for S3 Object Lock. Default retention can be configured after a bucket is created if the bucket already has object lock enabled. Enabling object lock for existing buckets is not supported. Default: no default retention period
        :param object_lock_enabled: Enable object lock on the bucket. Enabling object lock for existing buckets is not supported. Object lock must be enabled when the bucket is created. Default: false, unless objectLockDefaultRetention is set (then, true)
        :param object_ownership: The objectOwnership of the bucket. Default: - No ObjectOwnership configuration, uploading account will own the object.
        :param public_read_access: Grants public read access to all objects in the bucket. Similar to calling ``bucket.grantPublicAccess()`` Default: false
        :param removal_policy: Policy to apply when the bucket is removed from this stack. Default: - The bucket will be orphaned.
        :param server_access_logs_bucket: Destination bucket for the server access logs. Default: - If "serverAccessLogsPrefix" undefined - access logs disabled, otherwise - log to current bucket.
        :param server_access_logs_prefix: Optional log file prefix to use for the bucket's access logs. If defined without "serverAccessLogsBucket", enables access logs to current bucket with this prefix. Default: - No log file prefix
        :param transfer_acceleration: Whether this bucket should have transfer acceleration turned on or not. Default: false
        :param versioned: Whether this bucket should have versioning turned on or not. Default: false (unless object lock is enabled, then true)
        :param website_error_document: The name of the error document (e.g. "404.html") for the website. ``websiteIndexDocument`` must also be set if this is set. Default: - No error document.
        :param website_index_document: The name of the index document (e.g. "index.html") for the website. Enables static website hosting for this bucket. Default: - No index document.
        :param website_redirect: Specifies the redirect behavior of all requests to a website endpoint of a bucket. If you specify this property, you can't specify "websiteIndexDocument", "websiteErrorDocument" nor , "websiteRoutingRules". Default: - No redirection.
        :param website_routing_rules: Rules that define when a redirect is applied and the redirect behavior. Default: - No redirection rules.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__302aa44a04efd7039f32314924ad83f7735955102f1c3d6163fb082aae834c76)
            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 = _aws_cdk_aws_s3_ceddda9d.BucketProps(
            access_control=access_control,
            auto_delete_objects=auto_delete_objects,
            block_public_access=block_public_access,
            bucket_key_enabled=bucket_key_enabled,
            bucket_name=bucket_name,
            cors=cors,
            encryption=encryption,
            encryption_key=encryption_key,
            enforce_ssl=enforce_ssl,
            event_bridge_enabled=event_bridge_enabled,
            intelligent_tiering_configurations=intelligent_tiering_configurations,
            inventories=inventories,
            lifecycle_rules=lifecycle_rules,
            metrics=metrics,
            notifications_handler_role=notifications_handler_role,
            object_lock_default_retention=object_lock_default_retention,
            object_lock_enabled=object_lock_enabled,
            object_ownership=object_ownership,
            public_read_access=public_read_access,
            removal_policy=removal_policy,
            server_access_logs_bucket=server_access_logs_bucket,
            server_access_logs_prefix=server_access_logs_prefix,
            transfer_acceleration=transfer_acceleration,
            versioned=versioned,
            website_error_document=website_error_document,
            website_index_document=website_index_document,
            website_redirect=website_redirect,
            website_routing_rules=website_routing_rules,
        )

        return typing.cast(_aws_cdk_aws_s3_ceddda9d.Bucket, jsii.sinvoke(cls, "bucket", [scope, id, props]))


class SnsFactory(metaclass=jsii.JSIIMeta, jsii_type="aws-ddk-core.SnsFactory"):
    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="secureSnsTopicPolicy")
    @builtins.classmethod
    def secure_sns_topic_policy(cls, topic: _aws_cdk_aws_sns_ceddda9d.ITopic) -> None:
        '''
        :param topic: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__576a40c037c0f9a1e8953e9d1b17a1026f7d596ac5fc54fc43e0d213874fae25)
            check_type(argname="argument topic", value=topic, expected_type=type_hints["topic"])
        return typing.cast(None, jsii.sinvoke(cls, "secureSnsTopicPolicy", [topic]))


@jsii.data_type(
    jsii_type="aws-ddk-core.SourceActionProps",
    jsii_struct_bases=[],
    name_mapping={
        "repository_name": "repositoryName",
        "branch": "branch",
        "source_action": "sourceAction",
    },
)
class SourceActionProps:
    def __init__(
        self,
        *,
        repository_name: builtins.str,
        branch: typing.Optional[builtins.str] = None,
        source_action: typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipelineSource] = None,
    ) -> None:
        '''
        :param repository_name: 
        :param branch: 
        :param source_action: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8c722ae4d9bf55cce29be798641c0fc2edce1bd6666919da164ce1643888b11e)
            check_type(argname="argument repository_name", value=repository_name, expected_type=type_hints["repository_name"])
            check_type(argname="argument branch", value=branch, expected_type=type_hints["branch"])
            check_type(argname="argument source_action", value=source_action, expected_type=type_hints["source_action"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "repository_name": repository_name,
        }
        if branch is not None:
            self._values["branch"] = branch
        if source_action is not None:
            self._values["source_action"] = source_action

    @builtins.property
    def repository_name(self) -> builtins.str:
        result = self._values.get("repository_name")
        assert result is not None, "Required property 'repository_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def branch(self) -> typing.Optional[builtins.str]:
        result = self._values.get("branch")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def source_action(
        self,
    ) -> typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipelineSource]:
        result = self._values.get("source_action")
        return typing.cast(typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipelineSource], 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 "SourceActionProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.SqsToLambdaStageFunctionProps",
    jsii_struct_bases=[_aws_cdk_aws_lambda_ceddda9d.FunctionProps],
    name_mapping={
        "max_event_age": "maxEventAge",
        "on_failure": "onFailure",
        "on_success": "onSuccess",
        "retry_attempts": "retryAttempts",
        "adot_instrumentation": "adotInstrumentation",
        "allow_all_outbound": "allowAllOutbound",
        "allow_public_subnet": "allowPublicSubnet",
        "architecture": "architecture",
        "code_signing_config": "codeSigningConfig",
        "current_version_options": "currentVersionOptions",
        "dead_letter_queue": "deadLetterQueue",
        "dead_letter_queue_enabled": "deadLetterQueueEnabled",
        "dead_letter_topic": "deadLetterTopic",
        "description": "description",
        "environment": "environment",
        "environment_encryption": "environmentEncryption",
        "ephemeral_storage_size": "ephemeralStorageSize",
        "events": "events",
        "filesystem": "filesystem",
        "function_name": "functionName",
        "initial_policy": "initialPolicy",
        "insights_version": "insightsVersion",
        "layers": "layers",
        "log_retention": "logRetention",
        "log_retention_retry_options": "logRetentionRetryOptions",
        "log_retention_role": "logRetentionRole",
        "memory_size": "memorySize",
        "profiling": "profiling",
        "profiling_group": "profilingGroup",
        "reserved_concurrent_executions": "reservedConcurrentExecutions",
        "role": "role",
        "runtime_management_mode": "runtimeManagementMode",
        "security_groups": "securityGroups",
        "timeout": "timeout",
        "tracing": "tracing",
        "vpc": "vpc",
        "vpc_subnets": "vpcSubnets",
        "code": "code",
        "handler": "handler",
        "runtime": "runtime",
        "errors_alarm_threshold": "errorsAlarmThreshold",
        "errors_comparison_operator": "errorsComparisonOperator",
        "errors_evaluation_periods": "errorsEvaluationPeriods",
    },
)
class SqsToLambdaStageFunctionProps(_aws_cdk_aws_lambda_ceddda9d.FunctionProps):
    def __init__(
        self,
        *,
        max_event_age: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        on_failure: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IDestination] = None,
        on_success: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IDestination] = None,
        retry_attempts: typing.Optional[jsii.Number] = None,
        adot_instrumentation: typing.Optional[typing.Union[_aws_cdk_aws_lambda_ceddda9d.AdotInstrumentationConfig, typing.Dict[builtins.str, typing.Any]]] = None,
        allow_all_outbound: typing.Optional[builtins.bool] = None,
        allow_public_subnet: typing.Optional[builtins.bool] = None,
        architecture: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Architecture] = None,
        code_signing_config: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.ICodeSigningConfig] = None,
        current_version_options: typing.Optional[typing.Union[_aws_cdk_aws_lambda_ceddda9d.VersionOptions, typing.Dict[builtins.str, typing.Any]]] = None,
        dead_letter_queue: typing.Optional[_aws_cdk_aws_sqs_ceddda9d.IQueue] = None,
        dead_letter_queue_enabled: typing.Optional[builtins.bool] = None,
        dead_letter_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
        description: typing.Optional[builtins.str] = None,
        environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        environment_encryption: typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey] = None,
        ephemeral_storage_size: typing.Optional[_aws_cdk_ceddda9d.Size] = None,
        events: typing.Optional[typing.Sequence[_aws_cdk_aws_lambda_ceddda9d.IEventSource]] = None,
        filesystem: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.FileSystem] = None,
        function_name: typing.Optional[builtins.str] = None,
        initial_policy: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
        insights_version: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.LambdaInsightsVersion] = None,
        layers: typing.Optional[typing.Sequence[_aws_cdk_aws_lambda_ceddda9d.ILayerVersion]] = None,
        log_retention: typing.Optional[_aws_cdk_aws_logs_ceddda9d.RetentionDays] = None,
        log_retention_retry_options: typing.Optional[typing.Union[_aws_cdk_aws_lambda_ceddda9d.LogRetentionRetryOptions, typing.Dict[builtins.str, typing.Any]]] = None,
        log_retention_role: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole] = None,
        memory_size: typing.Optional[jsii.Number] = None,
        profiling: typing.Optional[builtins.bool] = None,
        profiling_group: typing.Optional[_aws_cdk_aws_codeguruprofiler_ceddda9d.IProfilingGroup] = None,
        reserved_concurrent_executions: typing.Optional[jsii.Number] = None,
        role: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole] = None,
        runtime_management_mode: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.RuntimeManagementMode] = None,
        security_groups: typing.Optional[typing.Sequence[_aws_cdk_aws_ec2_ceddda9d.ISecurityGroup]] = None,
        timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        tracing: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Tracing] = None,
        vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
        vpc_subnets: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
        code: _aws_cdk_aws_lambda_ceddda9d.Code,
        handler: builtins.str,
        runtime: _aws_cdk_aws_lambda_ceddda9d.Runtime,
        errors_alarm_threshold: typing.Optional[jsii.Number] = None,
        errors_comparison_operator: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        errors_evaluation_periods: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param max_event_age: The maximum age of a request that Lambda sends to a function for processing. Minimum: 60 seconds Maximum: 6 hours Default: Duration.hours(6)
        :param on_failure: The destination for failed invocations. Default: - no destination
        :param on_success: The destination for successful invocations. Default: - no destination
        :param retry_attempts: The maximum number of times to retry when the function returns an error. Minimum: 0 Maximum: 2 Default: 2
        :param adot_instrumentation: Specify the configuration of AWS Distro for OpenTelemetry (ADOT) instrumentation. Default: - No ADOT instrumentation
        :param allow_all_outbound: Whether to allow the Lambda to send all network traffic. If set to false, you must individually add traffic rules to allow the Lambda to connect to network targets. Default: true
        :param allow_public_subnet: Lambda Functions in a public subnet can NOT access the internet. Use this property to acknowledge this limitation and still place the function in a public subnet. Default: false
        :param architecture: The system architectures compatible with this lambda function. Default: Architecture.X86_64
        :param code_signing_config: Code signing config associated with this function. Default: - Not Sign the Code
        :param current_version_options: Options for the ``lambda.Version`` resource automatically created by the ``fn.currentVersion`` method. Default: - default options as described in ``VersionOptions``
        :param dead_letter_queue: The SQS queue to use if DLQ is enabled. If SNS topic is desired, specify ``deadLetterTopic`` property instead. Default: - SQS queue with 14 day retention period if ``deadLetterQueueEnabled`` is ``true``
        :param dead_letter_queue_enabled: Enabled DLQ. If ``deadLetterQueue`` is undefined, an SQS queue with default options will be defined for your Function. Default: - false unless ``deadLetterQueue`` is set, which implies DLQ is enabled.
        :param dead_letter_topic: The SNS topic to use as a DLQ. Note that if ``deadLetterQueueEnabled`` is set to ``true``, an SQS queue will be created rather than an SNS topic. Using an SNS topic as a DLQ requires this property to be set explicitly. Default: - no SNS topic
        :param description: A description of the function. Default: - No description.
        :param environment: Key-value pairs that Lambda caches and makes available for your Lambda functions. Use environment variables to apply configuration changes, such as test and production environment configurations, without changing your Lambda function source code. Default: - No environment variables.
        :param environment_encryption: The AWS KMS key that's used to encrypt your function's environment variables. Default: - AWS Lambda creates and uses an AWS managed customer master key (CMK).
        :param ephemeral_storage_size: The size of the function’s /tmp directory in MiB. Default: 512 MiB
        :param events: Event sources for this function. You can also add event sources using ``addEventSource``. Default: - No event sources.
        :param filesystem: The filesystem configuration for the lambda function. Default: - will not mount any filesystem
        :param function_name: A name for the function. Default: - AWS CloudFormation generates a unique physical ID and uses that ID for the function's name. For more information, see Name Type.
        :param initial_policy: Initial policy statements to add to the created Lambda Role. You can call ``addToRolePolicy`` to the created lambda to add statements post creation. Default: - No policy statements are added to the created Lambda role.
        :param insights_version: Specify the version of CloudWatch Lambda insights to use for monitoring. Default: - No Lambda Insights
        :param layers: A list of layers to add to the function's execution environment. You can configure your Lambda function to pull in additional code during initialization in the form of layers. Layers are packages of libraries or other dependencies that can be used by multiple functions. Default: - No layers.
        :param log_retention: The number of days log events are kept in CloudWatch Logs. When updating this property, unsetting it doesn't remove the log retention policy. To remove the retention policy, set the value to ``INFINITE``. Default: logs.RetentionDays.INFINITE
        :param log_retention_retry_options: When log retention is specified, a custom resource attempts to create the CloudWatch log group. These options control the retry policy when interacting with CloudWatch APIs. Default: - Default AWS SDK retry options.
        :param log_retention_role: The IAM role for the Lambda function associated with the custom resource that sets the retention policy. Default: - A new role is created.
        :param memory_size: The amount of memory, in MB, that is allocated to your Lambda function. Lambda uses this value to proportionally allocate the amount of CPU power. For more information, see Resource Model in the AWS Lambda Developer Guide. Default: 128
        :param profiling: Enable profiling. Default: - No profiling.
        :param profiling_group: Profiling Group. Default: - A new profiling group will be created if ``profiling`` is set.
        :param reserved_concurrent_executions: The maximum of concurrent executions you want to reserve for the function. Default: - No specific limit - account limit.
        :param role: Lambda execution role. This is the role that will be assumed by the function upon execution. It controls the permissions that the function will have. The Role must be assumable by the 'lambda.amazonaws.com' service principal. The default Role automatically has permissions granted for Lambda execution. If you provide a Role, you must add the relevant AWS managed policies yourself. The relevant managed policies are "service-role/AWSLambdaBasicExecutionRole" and "service-role/AWSLambdaVPCAccessExecutionRole". Default: - A unique role will be generated for this lambda function. Both supplied and generated roles can always be changed by calling ``addToRolePolicy``.
        :param runtime_management_mode: Sets the runtime management configuration for a function's version. Default: Auto
        :param security_groups: The list of security groups to associate with the Lambda's network interfaces. Only used if 'vpc' is supplied. Default: - If the function is placed within a VPC and a security group is not specified, either by this or securityGroup prop, a dedicated security group will be created for this function.
        :param timeout: The function execution time (in seconds) after which Lambda terminates the function. Because the execution time affects cost, set this value based on the function's expected execution time. Default: Duration.seconds(3)
        :param tracing: Enable AWS X-Ray Tracing for Lambda Function. Default: Tracing.Disabled
        :param vpc: VPC network to place Lambda network interfaces. Specify this if the Lambda function needs to access resources in a VPC. This is required when ``vpcSubnets`` is specified. Default: - Function is not placed within a VPC.
        :param vpc_subnets: Where to place the network interfaces within the VPC. This requires ``vpc`` to be specified in order for interfaces to actually be placed in the subnets. If ``vpc`` is not specify, this will raise an error. Note: Internet access for Lambda Functions requires a NAT Gateway, so picking public subnets is not allowed (unless ``allowPublicSubnet`` is set to ``true``). Default: - the Vpc default strategy if not specified
        :param code: The source code of your Lambda function. You can point to a file in an Amazon Simple Storage Service (Amazon S3) bucket or specify your source code as inline text.
        :param handler: The name of the method within your code that Lambda calls to execute your function. The format includes the file name. It can also include namespaces and other qualifiers, depending on the runtime. For more information, see https://docs.aws.amazon.com/lambda/latest/dg/foundation-progmodel.html. Use ``Handler.FROM_IMAGE`` when defining a function from a Docker image. NOTE: If you specify your source code as inline text by specifying the ZipFile property within the Code property, specify index.function_name as the handler.
        :param runtime: The runtime environment for the Lambda function that you are uploading. For valid values, see the Runtime property in the AWS Lambda Developer Guide. Use ``Runtime.FROM_IMAGE`` when defining a function from a Docker image.
        :param errors_alarm_threshold: 
        :param errors_comparison_operator: 
        :param errors_evaluation_periods: 
        '''
        if isinstance(adot_instrumentation, dict):
            adot_instrumentation = _aws_cdk_aws_lambda_ceddda9d.AdotInstrumentationConfig(**adot_instrumentation)
        if isinstance(current_version_options, dict):
            current_version_options = _aws_cdk_aws_lambda_ceddda9d.VersionOptions(**current_version_options)
        if isinstance(log_retention_retry_options, dict):
            log_retention_retry_options = _aws_cdk_aws_lambda_ceddda9d.LogRetentionRetryOptions(**log_retention_retry_options)
        if isinstance(vpc_subnets, dict):
            vpc_subnets = _aws_cdk_aws_ec2_ceddda9d.SubnetSelection(**vpc_subnets)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cd35d3f7ab025a947f003bfa8401771bc19ba3bee2d5d3483d2a11a867543e9b)
            check_type(argname="argument max_event_age", value=max_event_age, expected_type=type_hints["max_event_age"])
            check_type(argname="argument on_failure", value=on_failure, expected_type=type_hints["on_failure"])
            check_type(argname="argument on_success", value=on_success, expected_type=type_hints["on_success"])
            check_type(argname="argument retry_attempts", value=retry_attempts, expected_type=type_hints["retry_attempts"])
            check_type(argname="argument adot_instrumentation", value=adot_instrumentation, expected_type=type_hints["adot_instrumentation"])
            check_type(argname="argument allow_all_outbound", value=allow_all_outbound, expected_type=type_hints["allow_all_outbound"])
            check_type(argname="argument allow_public_subnet", value=allow_public_subnet, expected_type=type_hints["allow_public_subnet"])
            check_type(argname="argument architecture", value=architecture, expected_type=type_hints["architecture"])
            check_type(argname="argument code_signing_config", value=code_signing_config, expected_type=type_hints["code_signing_config"])
            check_type(argname="argument current_version_options", value=current_version_options, expected_type=type_hints["current_version_options"])
            check_type(argname="argument dead_letter_queue", value=dead_letter_queue, expected_type=type_hints["dead_letter_queue"])
            check_type(argname="argument dead_letter_queue_enabled", value=dead_letter_queue_enabled, expected_type=type_hints["dead_letter_queue_enabled"])
            check_type(argname="argument dead_letter_topic", value=dead_letter_topic, expected_type=type_hints["dead_letter_topic"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
            check_type(argname="argument environment_encryption", value=environment_encryption, expected_type=type_hints["environment_encryption"])
            check_type(argname="argument ephemeral_storage_size", value=ephemeral_storage_size, expected_type=type_hints["ephemeral_storage_size"])
            check_type(argname="argument events", value=events, expected_type=type_hints["events"])
            check_type(argname="argument filesystem", value=filesystem, expected_type=type_hints["filesystem"])
            check_type(argname="argument function_name", value=function_name, expected_type=type_hints["function_name"])
            check_type(argname="argument initial_policy", value=initial_policy, expected_type=type_hints["initial_policy"])
            check_type(argname="argument insights_version", value=insights_version, expected_type=type_hints["insights_version"])
            check_type(argname="argument layers", value=layers, expected_type=type_hints["layers"])
            check_type(argname="argument log_retention", value=log_retention, expected_type=type_hints["log_retention"])
            check_type(argname="argument log_retention_retry_options", value=log_retention_retry_options, expected_type=type_hints["log_retention_retry_options"])
            check_type(argname="argument log_retention_role", value=log_retention_role, expected_type=type_hints["log_retention_role"])
            check_type(argname="argument memory_size", value=memory_size, expected_type=type_hints["memory_size"])
            check_type(argname="argument profiling", value=profiling, expected_type=type_hints["profiling"])
            check_type(argname="argument profiling_group", value=profiling_group, expected_type=type_hints["profiling_group"])
            check_type(argname="argument reserved_concurrent_executions", value=reserved_concurrent_executions, expected_type=type_hints["reserved_concurrent_executions"])
            check_type(argname="argument role", value=role, expected_type=type_hints["role"])
            check_type(argname="argument runtime_management_mode", value=runtime_management_mode, expected_type=type_hints["runtime_management_mode"])
            check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
            check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
            check_type(argname="argument tracing", value=tracing, expected_type=type_hints["tracing"])
            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
            check_type(argname="argument vpc_subnets", value=vpc_subnets, expected_type=type_hints["vpc_subnets"])
            check_type(argname="argument code", value=code, expected_type=type_hints["code"])
            check_type(argname="argument handler", value=handler, expected_type=type_hints["handler"])
            check_type(argname="argument runtime", value=runtime, expected_type=type_hints["runtime"])
            check_type(argname="argument errors_alarm_threshold", value=errors_alarm_threshold, expected_type=type_hints["errors_alarm_threshold"])
            check_type(argname="argument errors_comparison_operator", value=errors_comparison_operator, expected_type=type_hints["errors_comparison_operator"])
            check_type(argname="argument errors_evaluation_periods", value=errors_evaluation_periods, expected_type=type_hints["errors_evaluation_periods"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "code": code,
            "handler": handler,
            "runtime": runtime,
        }
        if max_event_age is not None:
            self._values["max_event_age"] = max_event_age
        if on_failure is not None:
            self._values["on_failure"] = on_failure
        if on_success is not None:
            self._values["on_success"] = on_success
        if retry_attempts is not None:
            self._values["retry_attempts"] = retry_attempts
        if adot_instrumentation is not None:
            self._values["adot_instrumentation"] = adot_instrumentation
        if allow_all_outbound is not None:
            self._values["allow_all_outbound"] = allow_all_outbound
        if allow_public_subnet is not None:
            self._values["allow_public_subnet"] = allow_public_subnet
        if architecture is not None:
            self._values["architecture"] = architecture
        if code_signing_config is not None:
            self._values["code_signing_config"] = code_signing_config
        if current_version_options is not None:
            self._values["current_version_options"] = current_version_options
        if dead_letter_queue is not None:
            self._values["dead_letter_queue"] = dead_letter_queue
        if dead_letter_queue_enabled is not None:
            self._values["dead_letter_queue_enabled"] = dead_letter_queue_enabled
        if dead_letter_topic is not None:
            self._values["dead_letter_topic"] = dead_letter_topic
        if description is not None:
            self._values["description"] = description
        if environment is not None:
            self._values["environment"] = environment
        if environment_encryption is not None:
            self._values["environment_encryption"] = environment_encryption
        if ephemeral_storage_size is not None:
            self._values["ephemeral_storage_size"] = ephemeral_storage_size
        if events is not None:
            self._values["events"] = events
        if filesystem is not None:
            self._values["filesystem"] = filesystem
        if function_name is not None:
            self._values["function_name"] = function_name
        if initial_policy is not None:
            self._values["initial_policy"] = initial_policy
        if insights_version is not None:
            self._values["insights_version"] = insights_version
        if layers is not None:
            self._values["layers"] = layers
        if log_retention is not None:
            self._values["log_retention"] = log_retention
        if log_retention_retry_options is not None:
            self._values["log_retention_retry_options"] = log_retention_retry_options
        if log_retention_role is not None:
            self._values["log_retention_role"] = log_retention_role
        if memory_size is not None:
            self._values["memory_size"] = memory_size
        if profiling is not None:
            self._values["profiling"] = profiling
        if profiling_group is not None:
            self._values["profiling_group"] = profiling_group
        if reserved_concurrent_executions is not None:
            self._values["reserved_concurrent_executions"] = reserved_concurrent_executions
        if role is not None:
            self._values["role"] = role
        if runtime_management_mode is not None:
            self._values["runtime_management_mode"] = runtime_management_mode
        if security_groups is not None:
            self._values["security_groups"] = security_groups
        if timeout is not None:
            self._values["timeout"] = timeout
        if tracing is not None:
            self._values["tracing"] = tracing
        if vpc is not None:
            self._values["vpc"] = vpc
        if vpc_subnets is not None:
            self._values["vpc_subnets"] = vpc_subnets
        if errors_alarm_threshold is not None:
            self._values["errors_alarm_threshold"] = errors_alarm_threshold
        if errors_comparison_operator is not None:
            self._values["errors_comparison_operator"] = errors_comparison_operator
        if errors_evaluation_periods is not None:
            self._values["errors_evaluation_periods"] = errors_evaluation_periods

    @builtins.property
    def max_event_age(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''The maximum age of a request that Lambda sends to a function for processing.

        Minimum: 60 seconds
        Maximum: 6 hours

        :default: Duration.hours(6)
        '''
        result = self._values.get("max_event_age")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def on_failure(self) -> typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IDestination]:
        '''The destination for failed invocations.

        :default: - no destination
        '''
        result = self._values.get("on_failure")
        return typing.cast(typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IDestination], result)

    @builtins.property
    def on_success(self) -> typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IDestination]:
        '''The destination for successful invocations.

        :default: - no destination
        '''
        result = self._values.get("on_success")
        return typing.cast(typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IDestination], result)

    @builtins.property
    def retry_attempts(self) -> typing.Optional[jsii.Number]:
        '''The maximum number of times to retry when the function returns an error.

        Minimum: 0
        Maximum: 2

        :default: 2
        '''
        result = self._values.get("retry_attempts")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def adot_instrumentation(
        self,
    ) -> typing.Optional[_aws_cdk_aws_lambda_ceddda9d.AdotInstrumentationConfig]:
        '''Specify the configuration of AWS Distro for OpenTelemetry (ADOT) instrumentation.

        :default: - No ADOT instrumentation

        :see: https://aws-otel.github.io/docs/getting-started/lambda
        '''
        result = self._values.get("adot_instrumentation")
        return typing.cast(typing.Optional[_aws_cdk_aws_lambda_ceddda9d.AdotInstrumentationConfig], result)

    @builtins.property
    def allow_all_outbound(self) -> typing.Optional[builtins.bool]:
        '''Whether to allow the Lambda to send all network traffic.

        If set to false, you must individually add traffic rules to allow the
        Lambda to connect to network targets.

        :default: true
        '''
        result = self._values.get("allow_all_outbound")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def allow_public_subnet(self) -> typing.Optional[builtins.bool]:
        '''Lambda Functions in a public subnet can NOT access the internet.

        Use this property to acknowledge this limitation and still place the function in a public subnet.

        :default: false

        :see: https://stackoverflow.com/questions/52992085/why-cant-an-aws-lambda-function-inside-a-public-subnet-in-a-vpc-connect-to-the/52994841#52994841
        '''
        result = self._values.get("allow_public_subnet")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def architecture(
        self,
    ) -> typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Architecture]:
        '''The system architectures compatible with this lambda function.

        :default: Architecture.X86_64
        '''
        result = self._values.get("architecture")
        return typing.cast(typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Architecture], result)

    @builtins.property
    def code_signing_config(
        self,
    ) -> typing.Optional[_aws_cdk_aws_lambda_ceddda9d.ICodeSigningConfig]:
        '''Code signing config associated with this function.

        :default: - Not Sign the Code
        '''
        result = self._values.get("code_signing_config")
        return typing.cast(typing.Optional[_aws_cdk_aws_lambda_ceddda9d.ICodeSigningConfig], result)

    @builtins.property
    def current_version_options(
        self,
    ) -> typing.Optional[_aws_cdk_aws_lambda_ceddda9d.VersionOptions]:
        '''Options for the ``lambda.Version`` resource automatically created by the ``fn.currentVersion`` method.

        :default: - default options as described in ``VersionOptions``
        '''
        result = self._values.get("current_version_options")
        return typing.cast(typing.Optional[_aws_cdk_aws_lambda_ceddda9d.VersionOptions], result)

    @builtins.property
    def dead_letter_queue(self) -> typing.Optional[_aws_cdk_aws_sqs_ceddda9d.IQueue]:
        '''The SQS queue to use if DLQ is enabled.

        If SNS topic is desired, specify ``deadLetterTopic`` property instead.

        :default: - SQS queue with 14 day retention period if ``deadLetterQueueEnabled`` is ``true``
        '''
        result = self._values.get("dead_letter_queue")
        return typing.cast(typing.Optional[_aws_cdk_aws_sqs_ceddda9d.IQueue], result)

    @builtins.property
    def dead_letter_queue_enabled(self) -> typing.Optional[builtins.bool]:
        '''Enabled DLQ.

        If ``deadLetterQueue`` is undefined,
        an SQS queue with default options will be defined for your Function.

        :default: - false unless ``deadLetterQueue`` is set, which implies DLQ is enabled.
        '''
        result = self._values.get("dead_letter_queue_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def dead_letter_topic(self) -> typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic]:
        '''The SNS topic to use as a DLQ.

        Note that if ``deadLetterQueueEnabled`` is set to ``true``, an SQS queue will be created
        rather than an SNS topic. Using an SNS topic as a DLQ requires this property to be set explicitly.

        :default: - no SNS topic
        '''
        result = self._values.get("dead_letter_topic")
        return typing.cast(typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A description of the function.

        :default: - No description.
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def environment(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        '''Key-value pairs that Lambda caches and makes available for your Lambda functions.

        Use environment variables to apply configuration changes, such
        as test and production environment configurations, without changing your
        Lambda function source code.

        :default: - No environment variables.
        '''
        result = self._values.get("environment")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    @builtins.property
    def environment_encryption(self) -> typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey]:
        '''The AWS KMS key that's used to encrypt your function's environment variables.

        :default: - AWS Lambda creates and uses an AWS managed customer master key (CMK).
        '''
        result = self._values.get("environment_encryption")
        return typing.cast(typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey], result)

    @builtins.property
    def ephemeral_storage_size(self) -> typing.Optional[_aws_cdk_ceddda9d.Size]:
        '''The size of the function’s /tmp directory in MiB.

        :default: 512 MiB
        '''
        result = self._values.get("ephemeral_storage_size")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Size], result)

    @builtins.property
    def events(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_lambda_ceddda9d.IEventSource]]:
        '''Event sources for this function.

        You can also add event sources using ``addEventSource``.

        :default: - No event sources.
        '''
        result = self._values.get("events")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_lambda_ceddda9d.IEventSource]], result)

    @builtins.property
    def filesystem(self) -> typing.Optional[_aws_cdk_aws_lambda_ceddda9d.FileSystem]:
        '''The filesystem configuration for the lambda function.

        :default: - will not mount any filesystem
        '''
        result = self._values.get("filesystem")
        return typing.cast(typing.Optional[_aws_cdk_aws_lambda_ceddda9d.FileSystem], result)

    @builtins.property
    def function_name(self) -> typing.Optional[builtins.str]:
        '''A name for the function.

        :default:

        - AWS CloudFormation generates a unique physical ID and uses that
        ID for the function's name. For more information, see Name Type.
        '''
        result = self._values.get("function_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def initial_policy(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]]:
        '''Initial policy statements to add to the created Lambda Role.

        You can call ``addToRolePolicy`` to the created lambda to add statements post creation.

        :default: - No policy statements are added to the created Lambda role.
        '''
        result = self._values.get("initial_policy")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]], result)

    @builtins.property
    def insights_version(
        self,
    ) -> typing.Optional[_aws_cdk_aws_lambda_ceddda9d.LambdaInsightsVersion]:
        '''Specify the version of CloudWatch Lambda insights to use for monitoring.

        :default: - No Lambda Insights

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Lambda-Insights-Getting-Started-docker.html
        '''
        result = self._values.get("insights_version")
        return typing.cast(typing.Optional[_aws_cdk_aws_lambda_ceddda9d.LambdaInsightsVersion], result)

    @builtins.property
    def layers(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_lambda_ceddda9d.ILayerVersion]]:
        '''A list of layers to add to the function's execution environment.

        You can configure your Lambda function to pull in
        additional code during initialization in the form of layers. Layers are packages of libraries or other dependencies
        that can be used by multiple functions.

        :default: - No layers.
        '''
        result = self._values.get("layers")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_lambda_ceddda9d.ILayerVersion]], result)

    @builtins.property
    def log_retention(
        self,
    ) -> typing.Optional[_aws_cdk_aws_logs_ceddda9d.RetentionDays]:
        '''The number of days log events are kept in CloudWatch Logs.

        When updating
        this property, unsetting it doesn't remove the log retention policy. To
        remove the retention policy, set the value to ``INFINITE``.

        :default: logs.RetentionDays.INFINITE
        '''
        result = self._values.get("log_retention")
        return typing.cast(typing.Optional[_aws_cdk_aws_logs_ceddda9d.RetentionDays], result)

    @builtins.property
    def log_retention_retry_options(
        self,
    ) -> typing.Optional[_aws_cdk_aws_lambda_ceddda9d.LogRetentionRetryOptions]:
        '''When log retention is specified, a custom resource attempts to create the CloudWatch log group.

        These options control the retry policy when interacting with CloudWatch APIs.

        :default: - Default AWS SDK retry options.
        '''
        result = self._values.get("log_retention_retry_options")
        return typing.cast(typing.Optional[_aws_cdk_aws_lambda_ceddda9d.LogRetentionRetryOptions], result)

    @builtins.property
    def log_retention_role(self) -> typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole]:
        '''The IAM role for the Lambda function associated with the custom resource that sets the retention policy.

        :default: - A new role is created.
        '''
        result = self._values.get("log_retention_role")
        return typing.cast(typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole], result)

    @builtins.property
    def memory_size(self) -> typing.Optional[jsii.Number]:
        '''The amount of memory, in MB, that is allocated to your Lambda function.

        Lambda uses this value to proportionally allocate the amount of CPU
        power. For more information, see Resource Model in the AWS Lambda
        Developer Guide.

        :default: 128
        '''
        result = self._values.get("memory_size")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def profiling(self) -> typing.Optional[builtins.bool]:
        '''Enable profiling.

        :default: - No profiling.

        :see: https://docs.aws.amazon.com/codeguru/latest/profiler-ug/setting-up-lambda.html
        '''
        result = self._values.get("profiling")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def profiling_group(
        self,
    ) -> typing.Optional[_aws_cdk_aws_codeguruprofiler_ceddda9d.IProfilingGroup]:
        '''Profiling Group.

        :default: - A new profiling group will be created if ``profiling`` is set.

        :see: https://docs.aws.amazon.com/codeguru/latest/profiler-ug/setting-up-lambda.html
        '''
        result = self._values.get("profiling_group")
        return typing.cast(typing.Optional[_aws_cdk_aws_codeguruprofiler_ceddda9d.IProfilingGroup], result)

    @builtins.property
    def reserved_concurrent_executions(self) -> typing.Optional[jsii.Number]:
        '''The maximum of concurrent executions you want to reserve for the function.

        :default: - No specific limit - account limit.

        :see: https://docs.aws.amazon.com/lambda/latest/dg/concurrent-executions.html
        '''
        result = self._values.get("reserved_concurrent_executions")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def role(self) -> typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole]:
        '''Lambda execution role.

        This is the role that will be assumed by the function upon execution.
        It controls the permissions that the function will have. The Role must
        be assumable by the 'lambda.amazonaws.com' service principal.

        The default Role automatically has permissions granted for Lambda execution. If you
        provide a Role, you must add the relevant AWS managed policies yourself.

        The relevant managed policies are "service-role/AWSLambdaBasicExecutionRole" and
        "service-role/AWSLambdaVPCAccessExecutionRole".

        :default:

        - A unique role will be generated for this lambda function.
        Both supplied and generated roles can always be changed by calling ``addToRolePolicy``.
        '''
        result = self._values.get("role")
        return typing.cast(typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole], result)

    @builtins.property
    def runtime_management_mode(
        self,
    ) -> typing.Optional[_aws_cdk_aws_lambda_ceddda9d.RuntimeManagementMode]:
        '''Sets the runtime management configuration for a function's version.

        :default: Auto
        '''
        result = self._values.get("runtime_management_mode")
        return typing.cast(typing.Optional[_aws_cdk_aws_lambda_ceddda9d.RuntimeManagementMode], result)

    @builtins.property
    def security_groups(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_ec2_ceddda9d.ISecurityGroup]]:
        '''The list of security groups to associate with the Lambda's network interfaces.

        Only used if 'vpc' is supplied.

        :default:

        - If the function is placed within a VPC and a security group is
        not specified, either by this or securityGroup prop, a dedicated security
        group will be created for this function.
        '''
        result = self._values.get("security_groups")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_ec2_ceddda9d.ISecurityGroup]], result)

    @builtins.property
    def timeout(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''The function execution time (in seconds) after which Lambda terminates the function.

        Because the execution time affects cost, set this value
        based on the function's expected execution time.

        :default: Duration.seconds(3)
        '''
        result = self._values.get("timeout")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def tracing(self) -> typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Tracing]:
        '''Enable AWS X-Ray Tracing for Lambda Function.

        :default: Tracing.Disabled
        '''
        result = self._values.get("tracing")
        return typing.cast(typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Tracing], result)

    @builtins.property
    def vpc(self) -> typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc]:
        '''VPC network to place Lambda network interfaces.

        Specify this if the Lambda function needs to access resources in a VPC.
        This is required when ``vpcSubnets`` is specified.

        :default: - Function is not placed within a VPC.
        '''
        result = self._values.get("vpc")
        return typing.cast(typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc], result)

    @builtins.property
    def vpc_subnets(self) -> typing.Optional[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection]:
        '''Where to place the network interfaces within the VPC.

        This requires ``vpc`` to be specified in order for interfaces to actually be
        placed in the subnets. If ``vpc`` is not specify, this will raise an error.

        Note: Internet access for Lambda Functions requires a NAT Gateway, so picking
        public subnets is not allowed (unless ``allowPublicSubnet`` is set to ``true``).

        :default: - the Vpc default strategy if not specified
        '''
        result = self._values.get("vpc_subnets")
        return typing.cast(typing.Optional[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection], result)

    @builtins.property
    def code(self) -> _aws_cdk_aws_lambda_ceddda9d.Code:
        '''The source code of your Lambda function.

        You can point to a file in an
        Amazon Simple Storage Service (Amazon S3) bucket or specify your source
        code as inline text.
        '''
        result = self._values.get("code")
        assert result is not None, "Required property 'code' is missing"
        return typing.cast(_aws_cdk_aws_lambda_ceddda9d.Code, result)

    @builtins.property
    def handler(self) -> builtins.str:
        '''The name of the method within your code that Lambda calls to execute your function.

        The format includes the file name. It can also include
        namespaces and other qualifiers, depending on the runtime.
        For more information, see https://docs.aws.amazon.com/lambda/latest/dg/foundation-progmodel.html.

        Use ``Handler.FROM_IMAGE`` when defining a function from a Docker image.

        NOTE: If you specify your source code as inline text by specifying the
        ZipFile property within the Code property, specify index.function_name as
        the handler.
        '''
        result = self._values.get("handler")
        assert result is not None, "Required property 'handler' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def runtime(self) -> _aws_cdk_aws_lambda_ceddda9d.Runtime:
        '''The runtime environment for the Lambda function that you are uploading.

        For valid values, see the Runtime property in the AWS Lambda Developer
        Guide.

        Use ``Runtime.FROM_IMAGE`` when defining a function from a Docker image.
        '''
        result = self._values.get("runtime")
        assert result is not None, "Required property 'runtime' is missing"
        return typing.cast(_aws_cdk_aws_lambda_ceddda9d.Runtime, result)

    @builtins.property
    def errors_alarm_threshold(self) -> typing.Optional[jsii.Number]:
        result = self._values.get("errors_alarm_threshold")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def errors_comparison_operator(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        result = self._values.get("errors_comparison_operator")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def errors_evaluation_periods(self) -> typing.Optional[jsii.Number]:
        result = self._values.get("errors_evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SqsToLambdaStageFunctionProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class Stage(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-ddk-core.Stage",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e9cf7c3474ce139a45c8e31d476f0b548b9db19082dbea4dffb9287504da5dff)
            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 = StageProps(description=description, name=name)

        jsii.create(self.__class__, self, [scope, id, props])

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @builtins.property
    @jsii.member(jsii_name="eventPattern")
    @abc.abstractmethod
    def event_pattern(
        self,
    ) -> typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern]:
        ...

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "name"))

    @builtins.property
    @jsii.member(jsii_name="targets")
    @abc.abstractmethod
    def targets(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]]:
        ...


class _StageProxy(Stage):
    @builtins.property
    @jsii.member(jsii_name="eventPattern")
    def event_pattern(
        self,
    ) -> typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern]:
        return typing.cast(typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern], jsii.get(self, "eventPattern"))

    @builtins.property
    @jsii.member(jsii_name="targets")
    def targets(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]]:
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]], jsii.get(self, "targets"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, Stage).__jsii_proxy_class__ = lambda : _StageProxy


@jsii.data_type(
    jsii_type="aws-ddk-core.StageProps",
    jsii_struct_bases=[],
    name_mapping={"description": "description", "name": "name"},
)
class StageProps:
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5e854dfb73af2b1e5b672ba3ec79ee122851867f8bde404e9918340757b3847c)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if name is not None:
            self._values["name"] = name

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("name")
        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 "StageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.StateMachineStageProps",
    jsii_struct_bases=[StageProps],
    name_mapping={
        "description": "description",
        "name": "name",
        "additional_role_policy_statements": "additionalRolePolicyStatements",
        "alarms_enabled": "alarmsEnabled",
        "state_machine_failed_executions_alarm_evaluation_periods": "stateMachineFailedExecutionsAlarmEvaluationPeriods",
        "state_machine_failed_executions_alarm_threshold": "stateMachineFailedExecutionsAlarmThreshold",
        "state_machine_input": "stateMachineInput",
        "state_machine_name": "stateMachineName",
    },
)
class StateMachineStageProps(StageProps):
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
        additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
        state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
        state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        state_machine_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param description: 
        :param name: 
        :param additional_role_policy_statements: 
        :param alarms_enabled: 
        :param state_machine_failed_executions_alarm_evaluation_periods: 
        :param state_machine_failed_executions_alarm_threshold: 
        :param state_machine_input: 
        :param state_machine_name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5069a8477e1d868a51858f29afe4a12917625d0a7370bc4090fd23bf809c081c)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument additional_role_policy_statements", value=additional_role_policy_statements, expected_type=type_hints["additional_role_policy_statements"])
            check_type(argname="argument alarms_enabled", value=alarms_enabled, expected_type=type_hints["alarms_enabled"])
            check_type(argname="argument state_machine_failed_executions_alarm_evaluation_periods", value=state_machine_failed_executions_alarm_evaluation_periods, expected_type=type_hints["state_machine_failed_executions_alarm_evaluation_periods"])
            check_type(argname="argument state_machine_failed_executions_alarm_threshold", value=state_machine_failed_executions_alarm_threshold, expected_type=type_hints["state_machine_failed_executions_alarm_threshold"])
            check_type(argname="argument state_machine_input", value=state_machine_input, expected_type=type_hints["state_machine_input"])
            check_type(argname="argument state_machine_name", value=state_machine_name, expected_type=type_hints["state_machine_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if name is not None:
            self._values["name"] = name
        if additional_role_policy_statements is not None:
            self._values["additional_role_policy_statements"] = additional_role_policy_statements
        if alarms_enabled is not None:
            self._values["alarms_enabled"] = alarms_enabled
        if state_machine_failed_executions_alarm_evaluation_periods is not None:
            self._values["state_machine_failed_executions_alarm_evaluation_periods"] = state_machine_failed_executions_alarm_evaluation_periods
        if state_machine_failed_executions_alarm_threshold is not None:
            self._values["state_machine_failed_executions_alarm_threshold"] = state_machine_failed_executions_alarm_threshold
        if state_machine_input is not None:
            self._values["state_machine_input"] = state_machine_input
        if state_machine_name is not None:
            self._values["state_machine_name"] = state_machine_name

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def additional_role_policy_statements(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]]:
        result = self._values.get("additional_role_policy_statements")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]], result)

    @builtins.property
    def alarms_enabled(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("alarms_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def state_machine_failed_executions_alarm_evaluation_periods(
        self,
    ) -> typing.Optional[jsii.Number]:
        result = self._values.get("state_machine_failed_executions_alarm_evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def state_machine_failed_executions_alarm_threshold(
        self,
    ) -> typing.Optional[jsii.Number]:
        result = self._values.get("state_machine_failed_executions_alarm_threshold")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def state_machine_input(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        result = self._values.get("state_machine_input")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def state_machine_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("state_machine_name")
        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 "StateMachineStageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.SynthActionProps",
    jsii_struct_bases=[],
    name_mapping={
        "additional_install_commands": "additionalInstallCommands",
        "cdk_version": "cdkVersion",
        "codeartifact_domain": "codeartifactDomain",
        "codeartifact_domain_owner": "codeartifactDomainOwner",
        "codeartifact_repository": "codeartifactRepository",
        "role_policy_statements": "rolePolicyStatements",
        "synth_action": "synthAction",
    },
)
class SynthActionProps:
    def __init__(
        self,
        *,
        additional_install_commands: typing.Optional[typing.Sequence[builtins.str]] = None,
        cdk_version: typing.Optional[builtins.str] = None,
        codeartifact_domain: typing.Optional[builtins.str] = None,
        codeartifact_domain_owner: typing.Optional[builtins.str] = None,
        codeartifact_repository: typing.Optional[builtins.str] = None,
        role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
        synth_action: typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildStep] = None,
    ) -> None:
        '''
        :param additional_install_commands: 
        :param cdk_version: 
        :param codeartifact_domain: 
        :param codeartifact_domain_owner: 
        :param codeartifact_repository: 
        :param role_policy_statements: 
        :param synth_action: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__05acfa3cda54a17101814d614a246f97dc36de4bf27ef87f72f7aa4824dd7b35)
            check_type(argname="argument additional_install_commands", value=additional_install_commands, expected_type=type_hints["additional_install_commands"])
            check_type(argname="argument cdk_version", value=cdk_version, expected_type=type_hints["cdk_version"])
            check_type(argname="argument codeartifact_domain", value=codeartifact_domain, expected_type=type_hints["codeartifact_domain"])
            check_type(argname="argument codeartifact_domain_owner", value=codeartifact_domain_owner, expected_type=type_hints["codeartifact_domain_owner"])
            check_type(argname="argument codeartifact_repository", value=codeartifact_repository, expected_type=type_hints["codeartifact_repository"])
            check_type(argname="argument role_policy_statements", value=role_policy_statements, expected_type=type_hints["role_policy_statements"])
            check_type(argname="argument synth_action", value=synth_action, expected_type=type_hints["synth_action"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if additional_install_commands is not None:
            self._values["additional_install_commands"] = additional_install_commands
        if cdk_version is not None:
            self._values["cdk_version"] = cdk_version
        if codeartifact_domain is not None:
            self._values["codeartifact_domain"] = codeartifact_domain
        if codeartifact_domain_owner is not None:
            self._values["codeartifact_domain_owner"] = codeartifact_domain_owner
        if codeartifact_repository is not None:
            self._values["codeartifact_repository"] = codeartifact_repository
        if role_policy_statements is not None:
            self._values["role_policy_statements"] = role_policy_statements
        if synth_action is not None:
            self._values["synth_action"] = synth_action

    @builtins.property
    def additional_install_commands(self) -> typing.Optional[typing.List[builtins.str]]:
        result = self._values.get("additional_install_commands")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def cdk_version(self) -> typing.Optional[builtins.str]:
        result = self._values.get("cdk_version")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def codeartifact_domain(self) -> typing.Optional[builtins.str]:
        result = self._values.get("codeartifact_domain")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def codeartifact_domain_owner(self) -> typing.Optional[builtins.str]:
        result = self._values.get("codeartifact_domain_owner")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def codeartifact_repository(self) -> typing.Optional[builtins.str]:
        result = self._values.get("codeartifact_repository")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def role_policy_statements(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]]:
        result = self._values.get("role_policy_statements")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]], result)

    @builtins.property
    def synth_action(
        self,
    ) -> typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildStep]:
        result = self._values.get("synth_action")
        return typing.cast(typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildStep], 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 "SynthActionProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.AppFlowIngestionStageProps",
    jsii_struct_bases=[StateMachineStageProps],
    name_mapping={
        "description": "description",
        "name": "name",
        "additional_role_policy_statements": "additionalRolePolicyStatements",
        "alarms_enabled": "alarmsEnabled",
        "state_machine_failed_executions_alarm_evaluation_periods": "stateMachineFailedExecutionsAlarmEvaluationPeriods",
        "state_machine_failed_executions_alarm_threshold": "stateMachineFailedExecutionsAlarmThreshold",
        "state_machine_input": "stateMachineInput",
        "state_machine_name": "stateMachineName",
        "destination_flow_config": "destinationFlowConfig",
        "flow_execution_status_check_period": "flowExecutionStatusCheckPeriod",
        "flow_name": "flowName",
        "flow_tasks": "flowTasks",
        "source_flow_config": "sourceFlowConfig",
    },
)
class AppFlowIngestionStageProps(StateMachineStageProps):
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
        additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
        state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
        state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        state_machine_name: typing.Optional[builtins.str] = None,
        destination_flow_config: typing.Optional[typing.Union[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.DestinationFlowConfigProperty, typing.Dict[builtins.str, typing.Any]]] = None,
        flow_execution_status_check_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        flow_name: typing.Optional[builtins.str] = None,
        flow_tasks: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.TaskProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        source_flow_config: typing.Optional[typing.Union[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.SourceFlowConfigProperty, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param description: 
        :param name: 
        :param additional_role_policy_statements: 
        :param alarms_enabled: 
        :param state_machine_failed_executions_alarm_evaluation_periods: 
        :param state_machine_failed_executions_alarm_threshold: 
        :param state_machine_input: 
        :param state_machine_name: 
        :param destination_flow_config: 
        :param flow_execution_status_check_period: 
        :param flow_name: 
        :param flow_tasks: 
        :param source_flow_config: 
        '''
        if isinstance(destination_flow_config, dict):
            destination_flow_config = _aws_cdk_aws_appflow_ceddda9d.CfnFlow.DestinationFlowConfigProperty(**destination_flow_config)
        if isinstance(source_flow_config, dict):
            source_flow_config = _aws_cdk_aws_appflow_ceddda9d.CfnFlow.SourceFlowConfigProperty(**source_flow_config)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__50f57d5c758f4bb8a7385b25c9dd1756786a7af562ac0cf743837ff675065839)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument additional_role_policy_statements", value=additional_role_policy_statements, expected_type=type_hints["additional_role_policy_statements"])
            check_type(argname="argument alarms_enabled", value=alarms_enabled, expected_type=type_hints["alarms_enabled"])
            check_type(argname="argument state_machine_failed_executions_alarm_evaluation_periods", value=state_machine_failed_executions_alarm_evaluation_periods, expected_type=type_hints["state_machine_failed_executions_alarm_evaluation_periods"])
            check_type(argname="argument state_machine_failed_executions_alarm_threshold", value=state_machine_failed_executions_alarm_threshold, expected_type=type_hints["state_machine_failed_executions_alarm_threshold"])
            check_type(argname="argument state_machine_input", value=state_machine_input, expected_type=type_hints["state_machine_input"])
            check_type(argname="argument state_machine_name", value=state_machine_name, expected_type=type_hints["state_machine_name"])
            check_type(argname="argument destination_flow_config", value=destination_flow_config, expected_type=type_hints["destination_flow_config"])
            check_type(argname="argument flow_execution_status_check_period", value=flow_execution_status_check_period, expected_type=type_hints["flow_execution_status_check_period"])
            check_type(argname="argument flow_name", value=flow_name, expected_type=type_hints["flow_name"])
            check_type(argname="argument flow_tasks", value=flow_tasks, expected_type=type_hints["flow_tasks"])
            check_type(argname="argument source_flow_config", value=source_flow_config, expected_type=type_hints["source_flow_config"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if name is not None:
            self._values["name"] = name
        if additional_role_policy_statements is not None:
            self._values["additional_role_policy_statements"] = additional_role_policy_statements
        if alarms_enabled is not None:
            self._values["alarms_enabled"] = alarms_enabled
        if state_machine_failed_executions_alarm_evaluation_periods is not None:
            self._values["state_machine_failed_executions_alarm_evaluation_periods"] = state_machine_failed_executions_alarm_evaluation_periods
        if state_machine_failed_executions_alarm_threshold is not None:
            self._values["state_machine_failed_executions_alarm_threshold"] = state_machine_failed_executions_alarm_threshold
        if state_machine_input is not None:
            self._values["state_machine_input"] = state_machine_input
        if state_machine_name is not None:
            self._values["state_machine_name"] = state_machine_name
        if destination_flow_config is not None:
            self._values["destination_flow_config"] = destination_flow_config
        if flow_execution_status_check_period is not None:
            self._values["flow_execution_status_check_period"] = flow_execution_status_check_period
        if flow_name is not None:
            self._values["flow_name"] = flow_name
        if flow_tasks is not None:
            self._values["flow_tasks"] = flow_tasks
        if source_flow_config is not None:
            self._values["source_flow_config"] = source_flow_config

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def additional_role_policy_statements(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]]:
        result = self._values.get("additional_role_policy_statements")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]], result)

    @builtins.property
    def alarms_enabled(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("alarms_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def state_machine_failed_executions_alarm_evaluation_periods(
        self,
    ) -> typing.Optional[jsii.Number]:
        result = self._values.get("state_machine_failed_executions_alarm_evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def state_machine_failed_executions_alarm_threshold(
        self,
    ) -> typing.Optional[jsii.Number]:
        result = self._values.get("state_machine_failed_executions_alarm_threshold")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def state_machine_input(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        result = self._values.get("state_machine_input")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def state_machine_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("state_machine_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def destination_flow_config(
        self,
    ) -> typing.Optional[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.DestinationFlowConfigProperty]:
        result = self._values.get("destination_flow_config")
        return typing.cast(typing.Optional[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.DestinationFlowConfigProperty], result)

    @builtins.property
    def flow_execution_status_check_period(
        self,
    ) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        result = self._values.get("flow_execution_status_check_period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def flow_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("flow_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def flow_tasks(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.TaskProperty]]:
        result = self._values.get("flow_tasks")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.TaskProperty]], result)

    @builtins.property
    def source_flow_config(
        self,
    ) -> typing.Optional[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.SourceFlowConfigProperty]:
        result = self._values.get("source_flow_config")
        return typing.cast(typing.Optional[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.SourceFlowConfigProperty], 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 "AppFlowIngestionStageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.AthenaToSQLStageProps",
    jsii_struct_bases=[StateMachineStageProps],
    name_mapping={
        "description": "description",
        "name": "name",
        "additional_role_policy_statements": "additionalRolePolicyStatements",
        "alarms_enabled": "alarmsEnabled",
        "state_machine_failed_executions_alarm_evaluation_periods": "stateMachineFailedExecutionsAlarmEvaluationPeriods",
        "state_machine_failed_executions_alarm_threshold": "stateMachineFailedExecutionsAlarmThreshold",
        "state_machine_input": "stateMachineInput",
        "state_machine_name": "stateMachineName",
        "catalog_name": "catalogName",
        "database_name": "databaseName",
        "encryption_key": "encryptionKey",
        "encryption_option": "encryptionOption",
        "output_location": "outputLocation",
        "query_string": "queryString",
        "query_string_path": "queryStringPath",
        "work_group": "workGroup",
    },
)
class AthenaToSQLStageProps(StateMachineStageProps):
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
        additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
        state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
        state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        state_machine_name: typing.Optional[builtins.str] = None,
        catalog_name: typing.Optional[builtins.str] = None,
        database_name: typing.Optional[builtins.str] = None,
        encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
        encryption_option: typing.Optional[_aws_cdk_aws_stepfunctions_tasks_ceddda9d.EncryptionOption] = None,
        output_location: typing.Optional[typing.Union[_aws_cdk_aws_s3_ceddda9d.Location, typing.Dict[builtins.str, typing.Any]]] = None,
        query_string: typing.Optional[builtins.str] = None,
        query_string_path: typing.Optional[builtins.str] = None,
        work_group: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param description: 
        :param name: 
        :param additional_role_policy_statements: 
        :param alarms_enabled: 
        :param state_machine_failed_executions_alarm_evaluation_periods: 
        :param state_machine_failed_executions_alarm_threshold: 
        :param state_machine_input: 
        :param state_machine_name: 
        :param catalog_name: 
        :param database_name: 
        :param encryption_key: 
        :param encryption_option: 
        :param output_location: 
        :param query_string: 
        :param query_string_path: 
        :param work_group: 
        '''
        if isinstance(output_location, dict):
            output_location = _aws_cdk_aws_s3_ceddda9d.Location(**output_location)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d02b2a3868910a4789cbcba2028e07a331d2da507e4b4c951dd7801d735bc0ac)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument additional_role_policy_statements", value=additional_role_policy_statements, expected_type=type_hints["additional_role_policy_statements"])
            check_type(argname="argument alarms_enabled", value=alarms_enabled, expected_type=type_hints["alarms_enabled"])
            check_type(argname="argument state_machine_failed_executions_alarm_evaluation_periods", value=state_machine_failed_executions_alarm_evaluation_periods, expected_type=type_hints["state_machine_failed_executions_alarm_evaluation_periods"])
            check_type(argname="argument state_machine_failed_executions_alarm_threshold", value=state_machine_failed_executions_alarm_threshold, expected_type=type_hints["state_machine_failed_executions_alarm_threshold"])
            check_type(argname="argument state_machine_input", value=state_machine_input, expected_type=type_hints["state_machine_input"])
            check_type(argname="argument state_machine_name", value=state_machine_name, expected_type=type_hints["state_machine_name"])
            check_type(argname="argument catalog_name", value=catalog_name, expected_type=type_hints["catalog_name"])
            check_type(argname="argument database_name", value=database_name, expected_type=type_hints["database_name"])
            check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
            check_type(argname="argument encryption_option", value=encryption_option, expected_type=type_hints["encryption_option"])
            check_type(argname="argument output_location", value=output_location, expected_type=type_hints["output_location"])
            check_type(argname="argument query_string", value=query_string, expected_type=type_hints["query_string"])
            check_type(argname="argument query_string_path", value=query_string_path, expected_type=type_hints["query_string_path"])
            check_type(argname="argument work_group", value=work_group, expected_type=type_hints["work_group"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if name is not None:
            self._values["name"] = name
        if additional_role_policy_statements is not None:
            self._values["additional_role_policy_statements"] = additional_role_policy_statements
        if alarms_enabled is not None:
            self._values["alarms_enabled"] = alarms_enabled
        if state_machine_failed_executions_alarm_evaluation_periods is not None:
            self._values["state_machine_failed_executions_alarm_evaluation_periods"] = state_machine_failed_executions_alarm_evaluation_periods
        if state_machine_failed_executions_alarm_threshold is not None:
            self._values["state_machine_failed_executions_alarm_threshold"] = state_machine_failed_executions_alarm_threshold
        if state_machine_input is not None:
            self._values["state_machine_input"] = state_machine_input
        if state_machine_name is not None:
            self._values["state_machine_name"] = state_machine_name
        if catalog_name is not None:
            self._values["catalog_name"] = catalog_name
        if database_name is not None:
            self._values["database_name"] = database_name
        if encryption_key is not None:
            self._values["encryption_key"] = encryption_key
        if encryption_option is not None:
            self._values["encryption_option"] = encryption_option
        if output_location is not None:
            self._values["output_location"] = output_location
        if query_string is not None:
            self._values["query_string"] = query_string
        if query_string_path is not None:
            self._values["query_string_path"] = query_string_path
        if work_group is not None:
            self._values["work_group"] = work_group

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def additional_role_policy_statements(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]]:
        result = self._values.get("additional_role_policy_statements")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]], result)

    @builtins.property
    def alarms_enabled(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("alarms_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def state_machine_failed_executions_alarm_evaluation_periods(
        self,
    ) -> typing.Optional[jsii.Number]:
        result = self._values.get("state_machine_failed_executions_alarm_evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def state_machine_failed_executions_alarm_threshold(
        self,
    ) -> typing.Optional[jsii.Number]:
        result = self._values.get("state_machine_failed_executions_alarm_threshold")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def state_machine_input(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        result = self._values.get("state_machine_input")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def state_machine_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("state_machine_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def catalog_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("catalog_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def database_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("database_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def encryption_key(self) -> typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key]:
        result = self._values.get("encryption_key")
        return typing.cast(typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key], result)

    @builtins.property
    def encryption_option(
        self,
    ) -> typing.Optional[_aws_cdk_aws_stepfunctions_tasks_ceddda9d.EncryptionOption]:
        result = self._values.get("encryption_option")
        return typing.cast(typing.Optional[_aws_cdk_aws_stepfunctions_tasks_ceddda9d.EncryptionOption], result)

    @builtins.property
    def output_location(self) -> typing.Optional[_aws_cdk_aws_s3_ceddda9d.Location]:
        result = self._values.get("output_location")
        return typing.cast(typing.Optional[_aws_cdk_aws_s3_ceddda9d.Location], result)

    @builtins.property
    def query_string(self) -> typing.Optional[builtins.str]:
        result = self._values.get("query_string")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def query_string_path(self) -> typing.Optional[builtins.str]:
        result = self._values.get("query_string_path")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def work_group(self) -> typing.Optional[builtins.str]:
        result = self._values.get("work_group")
        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 "AthenaToSQLStageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.DataBrewTransformStageProps",
    jsii_struct_bases=[StateMachineStageProps],
    name_mapping={
        "description": "description",
        "name": "name",
        "additional_role_policy_statements": "additionalRolePolicyStatements",
        "alarms_enabled": "alarmsEnabled",
        "state_machine_failed_executions_alarm_evaluation_periods": "stateMachineFailedExecutionsAlarmEvaluationPeriods",
        "state_machine_failed_executions_alarm_threshold": "stateMachineFailedExecutionsAlarmThreshold",
        "state_machine_input": "stateMachineInput",
        "state_machine_name": "stateMachineName",
        "create_job": "createJob",
        "database_outputs": "databaseOutputs",
        "data_catalog_outputs": "dataCatalogOutputs",
        "dataset_name": "datasetName",
        "encryption_key_arn": "encryptionKeyArn",
        "encryption_mode": "encryptionMode",
        "job_name": "jobName",
        "job_role_arn": "jobRoleArn",
        "job_sample": "jobSample",
        "job_type": "jobType",
        "log_subscription": "logSubscription",
        "max_capacity": "maxCapacity",
        "max_retries": "maxRetries",
        "output_location": "outputLocation",
        "outputs": "outputs",
        "profile_configuration": "profileConfiguration",
        "project_name": "projectName",
        "recipe": "recipe",
        "tags": "tags",
        "timeout": "timeout",
        "validation_configurations": "validationConfigurations",
    },
)
class DataBrewTransformStageProps(StateMachineStageProps):
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
        additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
        state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
        state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        state_machine_name: typing.Optional[builtins.str] = None,
        create_job: typing.Optional[builtins.bool] = None,
        database_outputs: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.DatabaseOutputProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        data_catalog_outputs: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.DataCatalogOutputProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        dataset_name: typing.Optional[builtins.str] = None,
        encryption_key_arn: typing.Optional[builtins.str] = None,
        encryption_mode: typing.Optional[builtins.str] = None,
        job_name: typing.Optional[builtins.str] = None,
        job_role_arn: typing.Optional[builtins.str] = None,
        job_sample: typing.Optional[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.JobSampleProperty, typing.Dict[builtins.str, typing.Any]]] = None,
        job_type: typing.Optional[builtins.str] = None,
        log_subscription: typing.Optional[builtins.str] = None,
        max_capacity: typing.Optional[jsii.Number] = None,
        max_retries: typing.Optional[jsii.Number] = None,
        output_location: typing.Optional[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.OutputLocationProperty, typing.Dict[builtins.str, typing.Any]]] = None,
        outputs: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.OutputProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        profile_configuration: typing.Optional[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.ProfileConfigurationProperty, typing.Dict[builtins.str, typing.Any]]] = None,
        project_name: typing.Optional[builtins.str] = None,
        recipe: typing.Optional[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.RecipeProperty, typing.Dict[builtins.str, typing.Any]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_ceddda9d.CfnTag, typing.Dict[builtins.str, typing.Any]]]] = None,
        timeout: typing.Optional[jsii.Number] = None,
        validation_configurations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.ValidationConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param description: 
        :param name: 
        :param additional_role_policy_statements: 
        :param alarms_enabled: 
        :param state_machine_failed_executions_alarm_evaluation_periods: 
        :param state_machine_failed_executions_alarm_threshold: 
        :param state_machine_input: 
        :param state_machine_name: 
        :param create_job: 
        :param database_outputs: 
        :param data_catalog_outputs: 
        :param dataset_name: 
        :param encryption_key_arn: 
        :param encryption_mode: 
        :param job_name: 
        :param job_role_arn: 
        :param job_sample: 
        :param job_type: 
        :param log_subscription: 
        :param max_capacity: 
        :param max_retries: 
        :param output_location: 
        :param outputs: 
        :param profile_configuration: 
        :param project_name: 
        :param recipe: 
        :param tags: 
        :param timeout: 
        :param validation_configurations: 
        '''
        if isinstance(job_sample, dict):
            job_sample = _aws_cdk_aws_databrew_ceddda9d.CfnJob.JobSampleProperty(**job_sample)
        if isinstance(output_location, dict):
            output_location = _aws_cdk_aws_databrew_ceddda9d.CfnJob.OutputLocationProperty(**output_location)
        if isinstance(profile_configuration, dict):
            profile_configuration = _aws_cdk_aws_databrew_ceddda9d.CfnJob.ProfileConfigurationProperty(**profile_configuration)
        if isinstance(recipe, dict):
            recipe = _aws_cdk_aws_databrew_ceddda9d.CfnJob.RecipeProperty(**recipe)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f6be6b9ec4e805f427307a7bc1c743a3f56ffd52c0cc37a1436d75ce69e31b9f)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument additional_role_policy_statements", value=additional_role_policy_statements, expected_type=type_hints["additional_role_policy_statements"])
            check_type(argname="argument alarms_enabled", value=alarms_enabled, expected_type=type_hints["alarms_enabled"])
            check_type(argname="argument state_machine_failed_executions_alarm_evaluation_periods", value=state_machine_failed_executions_alarm_evaluation_periods, expected_type=type_hints["state_machine_failed_executions_alarm_evaluation_periods"])
            check_type(argname="argument state_machine_failed_executions_alarm_threshold", value=state_machine_failed_executions_alarm_threshold, expected_type=type_hints["state_machine_failed_executions_alarm_threshold"])
            check_type(argname="argument state_machine_input", value=state_machine_input, expected_type=type_hints["state_machine_input"])
            check_type(argname="argument state_machine_name", value=state_machine_name, expected_type=type_hints["state_machine_name"])
            check_type(argname="argument create_job", value=create_job, expected_type=type_hints["create_job"])
            check_type(argname="argument database_outputs", value=database_outputs, expected_type=type_hints["database_outputs"])
            check_type(argname="argument data_catalog_outputs", value=data_catalog_outputs, expected_type=type_hints["data_catalog_outputs"])
            check_type(argname="argument dataset_name", value=dataset_name, expected_type=type_hints["dataset_name"])
            check_type(argname="argument encryption_key_arn", value=encryption_key_arn, expected_type=type_hints["encryption_key_arn"])
            check_type(argname="argument encryption_mode", value=encryption_mode, expected_type=type_hints["encryption_mode"])
            check_type(argname="argument job_name", value=job_name, expected_type=type_hints["job_name"])
            check_type(argname="argument job_role_arn", value=job_role_arn, expected_type=type_hints["job_role_arn"])
            check_type(argname="argument job_sample", value=job_sample, expected_type=type_hints["job_sample"])
            check_type(argname="argument job_type", value=job_type, expected_type=type_hints["job_type"])
            check_type(argname="argument log_subscription", value=log_subscription, expected_type=type_hints["log_subscription"])
            check_type(argname="argument max_capacity", value=max_capacity, expected_type=type_hints["max_capacity"])
            check_type(argname="argument max_retries", value=max_retries, expected_type=type_hints["max_retries"])
            check_type(argname="argument output_location", value=output_location, expected_type=type_hints["output_location"])
            check_type(argname="argument outputs", value=outputs, expected_type=type_hints["outputs"])
            check_type(argname="argument profile_configuration", value=profile_configuration, expected_type=type_hints["profile_configuration"])
            check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
            check_type(argname="argument recipe", value=recipe, expected_type=type_hints["recipe"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
            check_type(argname="argument validation_configurations", value=validation_configurations, expected_type=type_hints["validation_configurations"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if name is not None:
            self._values["name"] = name
        if additional_role_policy_statements is not None:
            self._values["additional_role_policy_statements"] = additional_role_policy_statements
        if alarms_enabled is not None:
            self._values["alarms_enabled"] = alarms_enabled
        if state_machine_failed_executions_alarm_evaluation_periods is not None:
            self._values["state_machine_failed_executions_alarm_evaluation_periods"] = state_machine_failed_executions_alarm_evaluation_periods
        if state_machine_failed_executions_alarm_threshold is not None:
            self._values["state_machine_failed_executions_alarm_threshold"] = state_machine_failed_executions_alarm_threshold
        if state_machine_input is not None:
            self._values["state_machine_input"] = state_machine_input
        if state_machine_name is not None:
            self._values["state_machine_name"] = state_machine_name
        if create_job is not None:
            self._values["create_job"] = create_job
        if database_outputs is not None:
            self._values["database_outputs"] = database_outputs
        if data_catalog_outputs is not None:
            self._values["data_catalog_outputs"] = data_catalog_outputs
        if dataset_name is not None:
            self._values["dataset_name"] = dataset_name
        if encryption_key_arn is not None:
            self._values["encryption_key_arn"] = encryption_key_arn
        if encryption_mode is not None:
            self._values["encryption_mode"] = encryption_mode
        if job_name is not None:
            self._values["job_name"] = job_name
        if job_role_arn is not None:
            self._values["job_role_arn"] = job_role_arn
        if job_sample is not None:
            self._values["job_sample"] = job_sample
        if job_type is not None:
            self._values["job_type"] = job_type
        if log_subscription is not None:
            self._values["log_subscription"] = log_subscription
        if max_capacity is not None:
            self._values["max_capacity"] = max_capacity
        if max_retries is not None:
            self._values["max_retries"] = max_retries
        if output_location is not None:
            self._values["output_location"] = output_location
        if outputs is not None:
            self._values["outputs"] = outputs
        if profile_configuration is not None:
            self._values["profile_configuration"] = profile_configuration
        if project_name is not None:
            self._values["project_name"] = project_name
        if recipe is not None:
            self._values["recipe"] = recipe
        if tags is not None:
            self._values["tags"] = tags
        if timeout is not None:
            self._values["timeout"] = timeout
        if validation_configurations is not None:
            self._values["validation_configurations"] = validation_configurations

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def additional_role_policy_statements(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]]:
        result = self._values.get("additional_role_policy_statements")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]], result)

    @builtins.property
    def alarms_enabled(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("alarms_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def state_machine_failed_executions_alarm_evaluation_periods(
        self,
    ) -> typing.Optional[jsii.Number]:
        result = self._values.get("state_machine_failed_executions_alarm_evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def state_machine_failed_executions_alarm_threshold(
        self,
    ) -> typing.Optional[jsii.Number]:
        result = self._values.get("state_machine_failed_executions_alarm_threshold")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def state_machine_input(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        result = self._values.get("state_machine_input")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def state_machine_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("state_machine_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def create_job(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("create_job")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def database_outputs(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_databrew_ceddda9d.CfnJob.DatabaseOutputProperty]]:
        result = self._values.get("database_outputs")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_databrew_ceddda9d.CfnJob.DatabaseOutputProperty]], result)

    @builtins.property
    def data_catalog_outputs(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_databrew_ceddda9d.CfnJob.DataCatalogOutputProperty]]:
        result = self._values.get("data_catalog_outputs")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_databrew_ceddda9d.CfnJob.DataCatalogOutputProperty]], result)

    @builtins.property
    def dataset_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("dataset_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def encryption_key_arn(self) -> typing.Optional[builtins.str]:
        result = self._values.get("encryption_key_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def encryption_mode(self) -> typing.Optional[builtins.str]:
        result = self._values.get("encryption_mode")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def job_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("job_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def job_role_arn(self) -> typing.Optional[builtins.str]:
        result = self._values.get("job_role_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def job_sample(
        self,
    ) -> typing.Optional[_aws_cdk_aws_databrew_ceddda9d.CfnJob.JobSampleProperty]:
        result = self._values.get("job_sample")
        return typing.cast(typing.Optional[_aws_cdk_aws_databrew_ceddda9d.CfnJob.JobSampleProperty], result)

    @builtins.property
    def job_type(self) -> typing.Optional[builtins.str]:
        result = self._values.get("job_type")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def log_subscription(self) -> typing.Optional[builtins.str]:
        result = self._values.get("log_subscription")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def max_capacity(self) -> typing.Optional[jsii.Number]:
        result = self._values.get("max_capacity")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def max_retries(self) -> typing.Optional[jsii.Number]:
        result = self._values.get("max_retries")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def output_location(
        self,
    ) -> typing.Optional[_aws_cdk_aws_databrew_ceddda9d.CfnJob.OutputLocationProperty]:
        result = self._values.get("output_location")
        return typing.cast(typing.Optional[_aws_cdk_aws_databrew_ceddda9d.CfnJob.OutputLocationProperty], result)

    @builtins.property
    def outputs(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_databrew_ceddda9d.CfnJob.OutputProperty]]:
        result = self._values.get("outputs")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_databrew_ceddda9d.CfnJob.OutputProperty]], result)

    @builtins.property
    def profile_configuration(
        self,
    ) -> typing.Optional[_aws_cdk_aws_databrew_ceddda9d.CfnJob.ProfileConfigurationProperty]:
        result = self._values.get("profile_configuration")
        return typing.cast(typing.Optional[_aws_cdk_aws_databrew_ceddda9d.CfnJob.ProfileConfigurationProperty], result)

    @builtins.property
    def project_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("project_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def recipe(
        self,
    ) -> typing.Optional[_aws_cdk_aws_databrew_ceddda9d.CfnJob.RecipeProperty]:
        result = self._values.get("recipe")
        return typing.cast(typing.Optional[_aws_cdk_aws_databrew_ceddda9d.CfnJob.RecipeProperty], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_aws_cdk_ceddda9d.CfnTag]]:
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_ceddda9d.CfnTag]], result)

    @builtins.property
    def timeout(self) -> typing.Optional[jsii.Number]:
        result = self._values.get("timeout")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def validation_configurations(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_databrew_ceddda9d.CfnJob.ValidationConfigurationProperty]]:
        result = self._values.get("validation_configurations")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_databrew_ceddda9d.CfnJob.ValidationConfigurationProperty]], 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 "DataBrewTransformStageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class DataStage(
    Stage,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-ddk-core.DataStage",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param alarms_enabled: 
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a7ee0133925b96b521f696b544f087847c2e6916f79bbdcf76306ed73653fdb2)
            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 = DataStageProps(
            alarms_enabled=alarms_enabled, description=description, name=name
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="addAlarm")
    def add_alarm(
        self,
        id: builtins.str,
        *,
        metric: _aws_cdk_aws_cloudwatch_ceddda9d.IMetric,
        comparison_operator: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        threshold: typing.Optional[jsii.Number] = None,
    ) -> "DataStage":
        '''
        :param id: -
        :param metric: 
        :param comparison_operator: 
        :param evaluation_periods: 
        :param threshold: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dfe170c2325021dad043fac92cbbedf46c28aacb0956794521a87dbad31593a0)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = AlarmProps(
            metric=metric,
            comparison_operator=comparison_operator,
            evaluation_periods=evaluation_periods,
            threshold=threshold,
        )

        return typing.cast("DataStage", jsii.invoke(self, "addAlarm", [id, props]))

    @builtins.property
    @jsii.member(jsii_name="alarmsEnabled")
    def alarms_enabled(self) -> builtins.bool:
        return typing.cast(builtins.bool, jsii.get(self, "alarmsEnabled"))

    @builtins.property
    @jsii.member(jsii_name="cloudwatchAlarms")
    def cloudwatch_alarms(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Alarm]:
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Alarm], jsii.get(self, "cloudwatchAlarms"))


class _DataStageProxy(
    DataStage,
    jsii.proxy_for(Stage), # type: ignore[misc]
):
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, DataStage).__jsii_proxy_class__ = lambda : _DataStageProxy


@jsii.data_type(
    jsii_type="aws-ddk-core.DataStageProps",
    jsii_struct_bases=[StageProps],
    name_mapping={
        "description": "description",
        "name": "name",
        "alarms_enabled": "alarmsEnabled",
    },
)
class DataStageProps(StageProps):
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param description: 
        :param name: 
        :param alarms_enabled: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1cf78e5b7c077cc8d8a6b8227060c5d2b68df15e3f29e358244b75ef0b897e42)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument alarms_enabled", value=alarms_enabled, expected_type=type_hints["alarms_enabled"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if name is not None:
            self._values["name"] = name
        if alarms_enabled is not None:
            self._values["alarms_enabled"] = alarms_enabled

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarms_enabled(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("alarms_enabled")
        return typing.cast(typing.Optional[builtins.bool], 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 "DataStageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class EventStage(
    Stage,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-ddk-core.EventStage",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__41f4bcf520b1f5e4739a71110428c14cbff5ea45be37a68ea1fe04dbffd91d83)
            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 = EventStageProps(description=description, name=name)

        jsii.create(self.__class__, self, [scope, id, props])

    @builtins.property
    @jsii.member(jsii_name="targets")
    def targets(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]]:
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]], jsii.get(self, "targets"))


class _EventStageProxy(
    EventStage,
    jsii.proxy_for(Stage), # type: ignore[misc]
):
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, EventStage).__jsii_proxy_class__ = lambda : _EventStageProxy


@jsii.data_type(
    jsii_type="aws-ddk-core.EventStageProps",
    jsii_struct_bases=[StageProps],
    name_mapping={"description": "description", "name": "name"},
)
class EventStageProps(StageProps):
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f2768fcf39322e444b8b05e9cfa0508e071c34b9e8a29e28fc79130506d7aeb6)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if name is not None:
            self._values["name"] = name

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("name")
        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 "EventStageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class FirehoseToS3Stage(
    DataStage,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-ddk-core.FirehoseToS3Stage",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        data_output_prefix: typing.Optional[builtins.str] = None,
        data_stream: typing.Optional[_aws_cdk_aws_kinesis_ceddda9d.Stream] = None,
        data_stream_enabled: typing.Optional[builtins.bool] = None,
        delivery_stream_data_freshness_errors_alarm_threshold: typing.Optional[jsii.Number] = None,
        delivery_stream_data_freshness_errors_evaluation_periods: typing.Optional[jsii.Number] = None,
        firehose_delivery_stream: typing.Optional[_aws_cdk_aws_kinesisfirehose_alpha_30daaf29.DeliveryStream] = None,
        firehose_delivery_stream_props: typing.Optional[typing.Union[DeliveryStreamProps, typing.Dict[builtins.str, typing.Any]]] = None,
        kinesis_firehose_destinations_s3_bucket_props: typing.Optional[typing.Union[_aws_cdk_aws_kinesisfirehose_destinations_alpha_8ee8dbdc.S3BucketProps, typing.Dict[builtins.str, typing.Any]]] = None,
        s3_bucket: typing.Optional[_aws_cdk_aws_s3_ceddda9d.IBucket] = None,
        s3_bucket_props: typing.Optional[typing.Union[_aws_cdk_aws_s3_ceddda9d.BucketProps, typing.Dict[builtins.str, typing.Any]]] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param data_output_prefix: 
        :param data_stream: 
        :param data_stream_enabled: 
        :param delivery_stream_data_freshness_errors_alarm_threshold: 
        :param delivery_stream_data_freshness_errors_evaluation_periods: 
        :param firehose_delivery_stream: 
        :param firehose_delivery_stream_props: 
        :param kinesis_firehose_destinations_s3_bucket_props: 
        :param s3_bucket: 
        :param s3_bucket_props: 
        :param alarms_enabled: 
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3f9217104050cf03ef7cf7519808ce659edfe6c1ba00722ea6601239921cfd56)
            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 = FirehoseToS3StageProps(
            data_output_prefix=data_output_prefix,
            data_stream=data_stream,
            data_stream_enabled=data_stream_enabled,
            delivery_stream_data_freshness_errors_alarm_threshold=delivery_stream_data_freshness_errors_alarm_threshold,
            delivery_stream_data_freshness_errors_evaluation_periods=delivery_stream_data_freshness_errors_evaluation_periods,
            firehose_delivery_stream=firehose_delivery_stream,
            firehose_delivery_stream_props=firehose_delivery_stream_props,
            kinesis_firehose_destinations_s3_bucket_props=kinesis_firehose_destinations_s3_bucket_props,
            s3_bucket=s3_bucket,
            s3_bucket_props=s3_bucket_props,
            alarms_enabled=alarms_enabled,
            description=description,
            name=name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @builtins.property
    @jsii.member(jsii_name="bucket")
    def bucket(self) -> _aws_cdk_aws_s3_ceddda9d.IBucket:
        return typing.cast(_aws_cdk_aws_s3_ceddda9d.IBucket, jsii.get(self, "bucket"))

    @builtins.property
    @jsii.member(jsii_name="deliveryStream")
    def delivery_stream(
        self,
    ) -> _aws_cdk_aws_kinesisfirehose_alpha_30daaf29.DeliveryStream:
        return typing.cast(_aws_cdk_aws_kinesisfirehose_alpha_30daaf29.DeliveryStream, jsii.get(self, "deliveryStream"))

    @builtins.property
    @jsii.member(jsii_name="dataStream")
    def data_stream(self) -> typing.Optional[_aws_cdk_aws_kinesis_ceddda9d.Stream]:
        return typing.cast(typing.Optional[_aws_cdk_aws_kinesis_ceddda9d.Stream], jsii.get(self, "dataStream"))

    @builtins.property
    @jsii.member(jsii_name="eventPattern")
    def event_pattern(
        self,
    ) -> typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern]:
        return typing.cast(typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern], jsii.get(self, "eventPattern"))

    @builtins.property
    @jsii.member(jsii_name="targets")
    def targets(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]]:
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]], jsii.get(self, "targets"))


@jsii.data_type(
    jsii_type="aws-ddk-core.FirehoseToS3StageProps",
    jsii_struct_bases=[DataStageProps],
    name_mapping={
        "description": "description",
        "name": "name",
        "alarms_enabled": "alarmsEnabled",
        "data_output_prefix": "dataOutputPrefix",
        "data_stream": "dataStream",
        "data_stream_enabled": "dataStreamEnabled",
        "delivery_stream_data_freshness_errors_alarm_threshold": "deliveryStreamDataFreshnessErrorsAlarmThreshold",
        "delivery_stream_data_freshness_errors_evaluation_periods": "deliveryStreamDataFreshnessErrorsEvaluationPeriods",
        "firehose_delivery_stream": "firehoseDeliveryStream",
        "firehose_delivery_stream_props": "firehoseDeliveryStreamProps",
        "kinesis_firehose_destinations_s3_bucket_props": "kinesisFirehoseDestinationsS3BucketProps",
        "s3_bucket": "s3Bucket",
        "s3_bucket_props": "s3BucketProps",
    },
)
class FirehoseToS3StageProps(DataStageProps):
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        data_output_prefix: typing.Optional[builtins.str] = None,
        data_stream: typing.Optional[_aws_cdk_aws_kinesis_ceddda9d.Stream] = None,
        data_stream_enabled: typing.Optional[builtins.bool] = None,
        delivery_stream_data_freshness_errors_alarm_threshold: typing.Optional[jsii.Number] = None,
        delivery_stream_data_freshness_errors_evaluation_periods: typing.Optional[jsii.Number] = None,
        firehose_delivery_stream: typing.Optional[_aws_cdk_aws_kinesisfirehose_alpha_30daaf29.DeliveryStream] = None,
        firehose_delivery_stream_props: typing.Optional[typing.Union[DeliveryStreamProps, typing.Dict[builtins.str, typing.Any]]] = None,
        kinesis_firehose_destinations_s3_bucket_props: typing.Optional[typing.Union[_aws_cdk_aws_kinesisfirehose_destinations_alpha_8ee8dbdc.S3BucketProps, typing.Dict[builtins.str, typing.Any]]] = None,
        s3_bucket: typing.Optional[_aws_cdk_aws_s3_ceddda9d.IBucket] = None,
        s3_bucket_props: typing.Optional[typing.Union[_aws_cdk_aws_s3_ceddda9d.BucketProps, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param description: 
        :param name: 
        :param alarms_enabled: 
        :param data_output_prefix: 
        :param data_stream: 
        :param data_stream_enabled: 
        :param delivery_stream_data_freshness_errors_alarm_threshold: 
        :param delivery_stream_data_freshness_errors_evaluation_periods: 
        :param firehose_delivery_stream: 
        :param firehose_delivery_stream_props: 
        :param kinesis_firehose_destinations_s3_bucket_props: 
        :param s3_bucket: 
        :param s3_bucket_props: 
        '''
        if isinstance(firehose_delivery_stream_props, dict):
            firehose_delivery_stream_props = DeliveryStreamProps(**firehose_delivery_stream_props)
        if isinstance(kinesis_firehose_destinations_s3_bucket_props, dict):
            kinesis_firehose_destinations_s3_bucket_props = _aws_cdk_aws_kinesisfirehose_destinations_alpha_8ee8dbdc.S3BucketProps(**kinesis_firehose_destinations_s3_bucket_props)
        if isinstance(s3_bucket_props, dict):
            s3_bucket_props = _aws_cdk_aws_s3_ceddda9d.BucketProps(**s3_bucket_props)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__701f035bba059b01929f2b8055755baf96f72f5089bc32da86d2dc3cacf0f767)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument alarms_enabled", value=alarms_enabled, expected_type=type_hints["alarms_enabled"])
            check_type(argname="argument data_output_prefix", value=data_output_prefix, expected_type=type_hints["data_output_prefix"])
            check_type(argname="argument data_stream", value=data_stream, expected_type=type_hints["data_stream"])
            check_type(argname="argument data_stream_enabled", value=data_stream_enabled, expected_type=type_hints["data_stream_enabled"])
            check_type(argname="argument delivery_stream_data_freshness_errors_alarm_threshold", value=delivery_stream_data_freshness_errors_alarm_threshold, expected_type=type_hints["delivery_stream_data_freshness_errors_alarm_threshold"])
            check_type(argname="argument delivery_stream_data_freshness_errors_evaluation_periods", value=delivery_stream_data_freshness_errors_evaluation_periods, expected_type=type_hints["delivery_stream_data_freshness_errors_evaluation_periods"])
            check_type(argname="argument firehose_delivery_stream", value=firehose_delivery_stream, expected_type=type_hints["firehose_delivery_stream"])
            check_type(argname="argument firehose_delivery_stream_props", value=firehose_delivery_stream_props, expected_type=type_hints["firehose_delivery_stream_props"])
            check_type(argname="argument kinesis_firehose_destinations_s3_bucket_props", value=kinesis_firehose_destinations_s3_bucket_props, expected_type=type_hints["kinesis_firehose_destinations_s3_bucket_props"])
            check_type(argname="argument s3_bucket", value=s3_bucket, expected_type=type_hints["s3_bucket"])
            check_type(argname="argument s3_bucket_props", value=s3_bucket_props, expected_type=type_hints["s3_bucket_props"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if name is not None:
            self._values["name"] = name
        if alarms_enabled is not None:
            self._values["alarms_enabled"] = alarms_enabled
        if data_output_prefix is not None:
            self._values["data_output_prefix"] = data_output_prefix
        if data_stream is not None:
            self._values["data_stream"] = data_stream
        if data_stream_enabled is not None:
            self._values["data_stream_enabled"] = data_stream_enabled
        if delivery_stream_data_freshness_errors_alarm_threshold is not None:
            self._values["delivery_stream_data_freshness_errors_alarm_threshold"] = delivery_stream_data_freshness_errors_alarm_threshold
        if delivery_stream_data_freshness_errors_evaluation_periods is not None:
            self._values["delivery_stream_data_freshness_errors_evaluation_periods"] = delivery_stream_data_freshness_errors_evaluation_periods
        if firehose_delivery_stream is not None:
            self._values["firehose_delivery_stream"] = firehose_delivery_stream
        if firehose_delivery_stream_props is not None:
            self._values["firehose_delivery_stream_props"] = firehose_delivery_stream_props
        if kinesis_firehose_destinations_s3_bucket_props is not None:
            self._values["kinesis_firehose_destinations_s3_bucket_props"] = kinesis_firehose_destinations_s3_bucket_props
        if s3_bucket is not None:
            self._values["s3_bucket"] = s3_bucket
        if s3_bucket_props is not None:
            self._values["s3_bucket_props"] = s3_bucket_props

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarms_enabled(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("alarms_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def data_output_prefix(self) -> typing.Optional[builtins.str]:
        result = self._values.get("data_output_prefix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def data_stream(self) -> typing.Optional[_aws_cdk_aws_kinesis_ceddda9d.Stream]:
        result = self._values.get("data_stream")
        return typing.cast(typing.Optional[_aws_cdk_aws_kinesis_ceddda9d.Stream], result)

    @builtins.property
    def data_stream_enabled(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("data_stream_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def delivery_stream_data_freshness_errors_alarm_threshold(
        self,
    ) -> typing.Optional[jsii.Number]:
        result = self._values.get("delivery_stream_data_freshness_errors_alarm_threshold")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def delivery_stream_data_freshness_errors_evaluation_periods(
        self,
    ) -> typing.Optional[jsii.Number]:
        result = self._values.get("delivery_stream_data_freshness_errors_evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def firehose_delivery_stream(
        self,
    ) -> typing.Optional[_aws_cdk_aws_kinesisfirehose_alpha_30daaf29.DeliveryStream]:
        result = self._values.get("firehose_delivery_stream")
        return typing.cast(typing.Optional[_aws_cdk_aws_kinesisfirehose_alpha_30daaf29.DeliveryStream], result)

    @builtins.property
    def firehose_delivery_stream_props(self) -> typing.Optional[DeliveryStreamProps]:
        result = self._values.get("firehose_delivery_stream_props")
        return typing.cast(typing.Optional[DeliveryStreamProps], result)

    @builtins.property
    def kinesis_firehose_destinations_s3_bucket_props(
        self,
    ) -> typing.Optional[_aws_cdk_aws_kinesisfirehose_destinations_alpha_8ee8dbdc.S3BucketProps]:
        result = self._values.get("kinesis_firehose_destinations_s3_bucket_props")
        return typing.cast(typing.Optional[_aws_cdk_aws_kinesisfirehose_destinations_alpha_8ee8dbdc.S3BucketProps], result)

    @builtins.property
    def s3_bucket(self) -> typing.Optional[_aws_cdk_aws_s3_ceddda9d.IBucket]:
        result = self._values.get("s3_bucket")
        return typing.cast(typing.Optional[_aws_cdk_aws_s3_ceddda9d.IBucket], result)

    @builtins.property
    def s3_bucket_props(self) -> typing.Optional[_aws_cdk_aws_s3_ceddda9d.BucketProps]:
        result = self._values.get("s3_bucket_props")
        return typing.cast(typing.Optional[_aws_cdk_aws_s3_ceddda9d.BucketProps], 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 "FirehoseToS3StageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.GlueTransformStageProps",
    jsii_struct_bases=[StateMachineStageProps],
    name_mapping={
        "description": "description",
        "name": "name",
        "additional_role_policy_statements": "additionalRolePolicyStatements",
        "alarms_enabled": "alarmsEnabled",
        "state_machine_failed_executions_alarm_evaluation_periods": "stateMachineFailedExecutionsAlarmEvaluationPeriods",
        "state_machine_failed_executions_alarm_threshold": "stateMachineFailedExecutionsAlarmThreshold",
        "state_machine_input": "stateMachineInput",
        "state_machine_name": "stateMachineName",
        "crawler_allow_failure": "crawlerAllowFailure",
        "crawler_name": "crawlerName",
        "crawler_props": "crawlerProps",
        "crawler_role": "crawlerRole",
        "database_name": "databaseName",
        "job_name": "jobName",
        "job_props": "jobProps",
        "job_run_args": "jobRunArgs",
        "state_machine_retry_backoff_rate": "stateMachineRetryBackoffRate",
        "state_machine_retry_interval": "stateMachineRetryInterval",
        "state_machine_retry_max_attempts": "stateMachineRetryMaxAttempts",
        "targets": "targets",
    },
)
class GlueTransformStageProps(StateMachineStageProps):
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
        additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
        state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
        state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        state_machine_name: typing.Optional[builtins.str] = None,
        crawler_allow_failure: typing.Optional[builtins.bool] = None,
        crawler_name: typing.Optional[builtins.str] = None,
        crawler_props: typing.Optional[typing.Union[_aws_cdk_aws_glue_ceddda9d.CfnCrawlerProps, typing.Dict[builtins.str, typing.Any]]] = None,
        crawler_role: typing.Optional[builtins.str] = None,
        database_name: typing.Optional[builtins.str] = None,
        job_name: typing.Optional[builtins.str] = None,
        job_props: typing.Optional[typing.Union[_aws_cdk_aws_glue_alpha_ce674d29.JobProps, typing.Dict[builtins.str, typing.Any]]] = None,
        job_run_args: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        state_machine_retry_backoff_rate: typing.Optional[jsii.Number] = None,
        state_machine_retry_interval: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        state_machine_retry_max_attempts: typing.Optional[jsii.Number] = None,
        targets: typing.Optional[typing.Union[_aws_cdk_aws_glue_ceddda9d.CfnCrawler.TargetsProperty, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param description: 
        :param name: 
        :param additional_role_policy_statements: 
        :param alarms_enabled: 
        :param state_machine_failed_executions_alarm_evaluation_periods: 
        :param state_machine_failed_executions_alarm_threshold: 
        :param state_machine_input: 
        :param state_machine_name: 
        :param crawler_allow_failure: 
        :param crawler_name: 
        :param crawler_props: 
        :param crawler_role: 
        :param database_name: 
        :param job_name: 
        :param job_props: 
        :param job_run_args: 
        :param state_machine_retry_backoff_rate: 
        :param state_machine_retry_interval: 
        :param state_machine_retry_max_attempts: 
        :param targets: 
        '''
        if isinstance(crawler_props, dict):
            crawler_props = _aws_cdk_aws_glue_ceddda9d.CfnCrawlerProps(**crawler_props)
        if isinstance(job_props, dict):
            job_props = _aws_cdk_aws_glue_alpha_ce674d29.JobProps(**job_props)
        if isinstance(targets, dict):
            targets = _aws_cdk_aws_glue_ceddda9d.CfnCrawler.TargetsProperty(**targets)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__36c864b97313236b09b597808a1574a4f4d21024bac872f4e182edbd9a3d0175)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument additional_role_policy_statements", value=additional_role_policy_statements, expected_type=type_hints["additional_role_policy_statements"])
            check_type(argname="argument alarms_enabled", value=alarms_enabled, expected_type=type_hints["alarms_enabled"])
            check_type(argname="argument state_machine_failed_executions_alarm_evaluation_periods", value=state_machine_failed_executions_alarm_evaluation_periods, expected_type=type_hints["state_machine_failed_executions_alarm_evaluation_periods"])
            check_type(argname="argument state_machine_failed_executions_alarm_threshold", value=state_machine_failed_executions_alarm_threshold, expected_type=type_hints["state_machine_failed_executions_alarm_threshold"])
            check_type(argname="argument state_machine_input", value=state_machine_input, expected_type=type_hints["state_machine_input"])
            check_type(argname="argument state_machine_name", value=state_machine_name, expected_type=type_hints["state_machine_name"])
            check_type(argname="argument crawler_allow_failure", value=crawler_allow_failure, expected_type=type_hints["crawler_allow_failure"])
            check_type(argname="argument crawler_name", value=crawler_name, expected_type=type_hints["crawler_name"])
            check_type(argname="argument crawler_props", value=crawler_props, expected_type=type_hints["crawler_props"])
            check_type(argname="argument crawler_role", value=crawler_role, expected_type=type_hints["crawler_role"])
            check_type(argname="argument database_name", value=database_name, expected_type=type_hints["database_name"])
            check_type(argname="argument job_name", value=job_name, expected_type=type_hints["job_name"])
            check_type(argname="argument job_props", value=job_props, expected_type=type_hints["job_props"])
            check_type(argname="argument job_run_args", value=job_run_args, expected_type=type_hints["job_run_args"])
            check_type(argname="argument state_machine_retry_backoff_rate", value=state_machine_retry_backoff_rate, expected_type=type_hints["state_machine_retry_backoff_rate"])
            check_type(argname="argument state_machine_retry_interval", value=state_machine_retry_interval, expected_type=type_hints["state_machine_retry_interval"])
            check_type(argname="argument state_machine_retry_max_attempts", value=state_machine_retry_max_attempts, expected_type=type_hints["state_machine_retry_max_attempts"])
            check_type(argname="argument targets", value=targets, expected_type=type_hints["targets"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if name is not None:
            self._values["name"] = name
        if additional_role_policy_statements is not None:
            self._values["additional_role_policy_statements"] = additional_role_policy_statements
        if alarms_enabled is not None:
            self._values["alarms_enabled"] = alarms_enabled
        if state_machine_failed_executions_alarm_evaluation_periods is not None:
            self._values["state_machine_failed_executions_alarm_evaluation_periods"] = state_machine_failed_executions_alarm_evaluation_periods
        if state_machine_failed_executions_alarm_threshold is not None:
            self._values["state_machine_failed_executions_alarm_threshold"] = state_machine_failed_executions_alarm_threshold
        if state_machine_input is not None:
            self._values["state_machine_input"] = state_machine_input
        if state_machine_name is not None:
            self._values["state_machine_name"] = state_machine_name
        if crawler_allow_failure is not None:
            self._values["crawler_allow_failure"] = crawler_allow_failure
        if crawler_name is not None:
            self._values["crawler_name"] = crawler_name
        if crawler_props is not None:
            self._values["crawler_props"] = crawler_props
        if crawler_role is not None:
            self._values["crawler_role"] = crawler_role
        if database_name is not None:
            self._values["database_name"] = database_name
        if job_name is not None:
            self._values["job_name"] = job_name
        if job_props is not None:
            self._values["job_props"] = job_props
        if job_run_args is not None:
            self._values["job_run_args"] = job_run_args
        if state_machine_retry_backoff_rate is not None:
            self._values["state_machine_retry_backoff_rate"] = state_machine_retry_backoff_rate
        if state_machine_retry_interval is not None:
            self._values["state_machine_retry_interval"] = state_machine_retry_interval
        if state_machine_retry_max_attempts is not None:
            self._values["state_machine_retry_max_attempts"] = state_machine_retry_max_attempts
        if targets is not None:
            self._values["targets"] = targets

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def additional_role_policy_statements(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]]:
        result = self._values.get("additional_role_policy_statements")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]], result)

    @builtins.property
    def alarms_enabled(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("alarms_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def state_machine_failed_executions_alarm_evaluation_periods(
        self,
    ) -> typing.Optional[jsii.Number]:
        result = self._values.get("state_machine_failed_executions_alarm_evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def state_machine_failed_executions_alarm_threshold(
        self,
    ) -> typing.Optional[jsii.Number]:
        result = self._values.get("state_machine_failed_executions_alarm_threshold")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def state_machine_input(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        result = self._values.get("state_machine_input")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def state_machine_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("state_machine_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def crawler_allow_failure(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("crawler_allow_failure")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def crawler_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("crawler_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def crawler_props(
        self,
    ) -> typing.Optional[_aws_cdk_aws_glue_ceddda9d.CfnCrawlerProps]:
        result = self._values.get("crawler_props")
        return typing.cast(typing.Optional[_aws_cdk_aws_glue_ceddda9d.CfnCrawlerProps], result)

    @builtins.property
    def crawler_role(self) -> typing.Optional[builtins.str]:
        result = self._values.get("crawler_role")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def database_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("database_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def job_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("job_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def job_props(self) -> typing.Optional[_aws_cdk_aws_glue_alpha_ce674d29.JobProps]:
        result = self._values.get("job_props")
        return typing.cast(typing.Optional[_aws_cdk_aws_glue_alpha_ce674d29.JobProps], result)

    @builtins.property
    def job_run_args(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        result = self._values.get("job_run_args")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def state_machine_retry_backoff_rate(self) -> typing.Optional[jsii.Number]:
        result = self._values.get("state_machine_retry_backoff_rate")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def state_machine_retry_interval(
        self,
    ) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        result = self._values.get("state_machine_retry_interval")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def state_machine_retry_max_attempts(self) -> typing.Optional[jsii.Number]:
        result = self._values.get("state_machine_retry_max_attempts")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def targets(
        self,
    ) -> typing.Optional[_aws_cdk_aws_glue_ceddda9d.CfnCrawler.TargetsProperty]:
        result = self._values.get("targets")
        return typing.cast(typing.Optional[_aws_cdk_aws_glue_ceddda9d.CfnCrawler.TargetsProperty], 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 "GlueTransformStageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-ddk-core.RedshiftDataApiStageProps",
    jsii_struct_bases=[StateMachineStageProps],
    name_mapping={
        "description": "description",
        "name": "name",
        "additional_role_policy_statements": "additionalRolePolicyStatements",
        "alarms_enabled": "alarmsEnabled",
        "state_machine_failed_executions_alarm_evaluation_periods": "stateMachineFailedExecutionsAlarmEvaluationPeriods",
        "state_machine_failed_executions_alarm_threshold": "stateMachineFailedExecutionsAlarmThreshold",
        "state_machine_input": "stateMachineInput",
        "state_machine_name": "stateMachineName",
        "redshift_cluster_identifier": "redshiftClusterIdentifier",
        "sql_statements": "sqlStatements",
        "database_name": "databaseName",
        "database_user": "databaseUser",
        "polling_time": "pollingTime",
    },
)
class RedshiftDataApiStageProps(StateMachineStageProps):
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
        additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
        state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
        state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        state_machine_name: typing.Optional[builtins.str] = None,
        redshift_cluster_identifier: builtins.str,
        sql_statements: typing.Sequence[builtins.str],
        database_name: typing.Optional[builtins.str] = None,
        database_user: typing.Optional[builtins.str] = None,
        polling_time: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    ) -> None:
        '''
        :param description: 
        :param name: 
        :param additional_role_policy_statements: 
        :param alarms_enabled: 
        :param state_machine_failed_executions_alarm_evaluation_periods: 
        :param state_machine_failed_executions_alarm_threshold: 
        :param state_machine_input: 
        :param state_machine_name: 
        :param redshift_cluster_identifier: 
        :param sql_statements: 
        :param database_name: 
        :param database_user: 
        :param polling_time: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__defbc9333f2b8b3e2d55373f9b0155e5f6e83609e9153dc24f619d747ca4f133)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument additional_role_policy_statements", value=additional_role_policy_statements, expected_type=type_hints["additional_role_policy_statements"])
            check_type(argname="argument alarms_enabled", value=alarms_enabled, expected_type=type_hints["alarms_enabled"])
            check_type(argname="argument state_machine_failed_executions_alarm_evaluation_periods", value=state_machine_failed_executions_alarm_evaluation_periods, expected_type=type_hints["state_machine_failed_executions_alarm_evaluation_periods"])
            check_type(argname="argument state_machine_failed_executions_alarm_threshold", value=state_machine_failed_executions_alarm_threshold, expected_type=type_hints["state_machine_failed_executions_alarm_threshold"])
            check_type(argname="argument state_machine_input", value=state_machine_input, expected_type=type_hints["state_machine_input"])
            check_type(argname="argument state_machine_name", value=state_machine_name, expected_type=type_hints["state_machine_name"])
            check_type(argname="argument redshift_cluster_identifier", value=redshift_cluster_identifier, expected_type=type_hints["redshift_cluster_identifier"])
            check_type(argname="argument sql_statements", value=sql_statements, expected_type=type_hints["sql_statements"])
            check_type(argname="argument database_name", value=database_name, expected_type=type_hints["database_name"])
            check_type(argname="argument database_user", value=database_user, expected_type=type_hints["database_user"])
            check_type(argname="argument polling_time", value=polling_time, expected_type=type_hints["polling_time"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "redshift_cluster_identifier": redshift_cluster_identifier,
            "sql_statements": sql_statements,
        }
        if description is not None:
            self._values["description"] = description
        if name is not None:
            self._values["name"] = name
        if additional_role_policy_statements is not None:
            self._values["additional_role_policy_statements"] = additional_role_policy_statements
        if alarms_enabled is not None:
            self._values["alarms_enabled"] = alarms_enabled
        if state_machine_failed_executions_alarm_evaluation_periods is not None:
            self._values["state_machine_failed_executions_alarm_evaluation_periods"] = state_machine_failed_executions_alarm_evaluation_periods
        if state_machine_failed_executions_alarm_threshold is not None:
            self._values["state_machine_failed_executions_alarm_threshold"] = state_machine_failed_executions_alarm_threshold
        if state_machine_input is not None:
            self._values["state_machine_input"] = state_machine_input
        if state_machine_name is not None:
            self._values["state_machine_name"] = state_machine_name
        if database_name is not None:
            self._values["database_name"] = database_name
        if database_user is not None:
            self._values["database_user"] = database_user
        if polling_time is not None:
            self._values["polling_time"] = polling_time

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def additional_role_policy_statements(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]]:
        result = self._values.get("additional_role_policy_statements")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]], result)

    @builtins.property
    def alarms_enabled(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("alarms_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def state_machine_failed_executions_alarm_evaluation_periods(
        self,
    ) -> typing.Optional[jsii.Number]:
        result = self._values.get("state_machine_failed_executions_alarm_evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def state_machine_failed_executions_alarm_threshold(
        self,
    ) -> typing.Optional[jsii.Number]:
        result = self._values.get("state_machine_failed_executions_alarm_threshold")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def state_machine_input(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        result = self._values.get("state_machine_input")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def state_machine_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("state_machine_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def redshift_cluster_identifier(self) -> builtins.str:
        result = self._values.get("redshift_cluster_identifier")
        assert result is not None, "Required property 'redshift_cluster_identifier' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def sql_statements(self) -> typing.List[builtins.str]:
        result = self._values.get("sql_statements")
        assert result is not None, "Required property 'sql_statements' is missing"
        return typing.cast(typing.List[builtins.str], result)

    @builtins.property
    def database_name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("database_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def database_user(self) -> typing.Optional[builtins.str]:
        result = self._values.get("database_user")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def polling_time(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        result = self._values.get("polling_time")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], 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 "RedshiftDataApiStageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class S3EventStage(
    EventStage,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-ddk-core.S3EventStage",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        bucket: typing.Union[_aws_cdk_aws_s3_ceddda9d.IBucket, typing.Sequence[_aws_cdk_aws_s3_ceddda9d.IBucket]],
        event_names: typing.Sequence[builtins.str],
        key_prefix: typing.Optional[typing.Union[builtins.str, typing.Sequence[builtins.str]]] = None,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param bucket: 
        :param event_names: 
        :param key_prefix: 
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__faeff4d3ae690cf668837c5bb7641744355445bfe3e6990816e841afad5a577f)
            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 = S3EventStageProps(
            bucket=bucket,
            event_names=event_names,
            key_prefix=key_prefix,
            description=description,
            name=name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @builtins.property
    @jsii.member(jsii_name="eventPattern")
    def event_pattern(
        self,
    ) -> typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern]:
        return typing.cast(typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern], jsii.get(self, "eventPattern"))


@jsii.data_type(
    jsii_type="aws-ddk-core.S3EventStageProps",
    jsii_struct_bases=[EventStageProps],
    name_mapping={
        "description": "description",
        "name": "name",
        "bucket": "bucket",
        "event_names": "eventNames",
        "key_prefix": "keyPrefix",
    },
)
class S3EventStageProps(EventStageProps):
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
        bucket: typing.Union[_aws_cdk_aws_s3_ceddda9d.IBucket, typing.Sequence[_aws_cdk_aws_s3_ceddda9d.IBucket]],
        event_names: typing.Sequence[builtins.str],
        key_prefix: typing.Optional[typing.Union[builtins.str, typing.Sequence[builtins.str]]] = None,
    ) -> None:
        '''
        :param description: 
        :param name: 
        :param bucket: 
        :param event_names: 
        :param key_prefix: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b66fa30f9df5c5a39526206778107c9f4992a0d357e41d5469d45e647a206a90)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument event_names", value=event_names, expected_type=type_hints["event_names"])
            check_type(argname="argument key_prefix", value=key_prefix, expected_type=type_hints["key_prefix"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bucket": bucket,
            "event_names": event_names,
        }
        if description is not None:
            self._values["description"] = description
        if name is not None:
            self._values["name"] = name
        if key_prefix is not None:
            self._values["key_prefix"] = key_prefix

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def bucket(
        self,
    ) -> typing.Union[_aws_cdk_aws_s3_ceddda9d.IBucket, typing.List[_aws_cdk_aws_s3_ceddda9d.IBucket]]:
        result = self._values.get("bucket")
        assert result is not None, "Required property 'bucket' is missing"
        return typing.cast(typing.Union[_aws_cdk_aws_s3_ceddda9d.IBucket, typing.List[_aws_cdk_aws_s3_ceddda9d.IBucket]], result)

    @builtins.property
    def event_names(self) -> typing.List[builtins.str]:
        result = self._values.get("event_names")
        assert result is not None, "Required property 'event_names' is missing"
        return typing.cast(typing.List[builtins.str], result)

    @builtins.property
    def key_prefix(
        self,
    ) -> typing.Optional[typing.Union[builtins.str, typing.List[builtins.str]]]:
        result = self._values.get("key_prefix")
        return typing.cast(typing.Optional[typing.Union[builtins.str, typing.List[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 "S3EventStageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class SqsToLambdaStage(
    DataStage,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-ddk-core.SqsToLambdaStage",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        batch_size: typing.Optional[jsii.Number] = None,
        dlq_enabled: typing.Optional[builtins.bool] = None,
        lambda_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IFunction] = None,
        lambda_function_props: typing.Optional[typing.Union[SqsToLambdaStageFunctionProps, typing.Dict[builtins.str, typing.Any]]] = None,
        max_batching_window: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        max_receive_count: typing.Optional[jsii.Number] = None,
        message_group_id: typing.Optional[builtins.str] = None,
        sqs_queue: typing.Optional[_aws_cdk_aws_sqs_ceddda9d.IQueue] = None,
        sqs_queue_props: typing.Optional[typing.Union[_aws_cdk_aws_sqs_ceddda9d.QueueProps, typing.Dict[builtins.str, typing.Any]]] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param batch_size: 
        :param dlq_enabled: 
        :param lambda_function: 
        :param lambda_function_props: 
        :param max_batching_window: 
        :param max_receive_count: 
        :param message_group_id: 
        :param sqs_queue: 
        :param sqs_queue_props: 
        :param alarms_enabled: 
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b5be1a85b67aa2deae08f66dcc56eb002282a0b357ba91df9339c1c9e2cb7401)
            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 = SqsToLambdaStageProps(
            batch_size=batch_size,
            dlq_enabled=dlq_enabled,
            lambda_function=lambda_function,
            lambda_function_props=lambda_function_props,
            max_batching_window=max_batching_window,
            max_receive_count=max_receive_count,
            message_group_id=message_group_id,
            sqs_queue=sqs_queue,
            sqs_queue_props=sqs_queue_props,
            alarms_enabled=alarms_enabled,
            description=description,
            name=name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @builtins.property
    @jsii.member(jsii_name="function")
    def function(self) -> _aws_cdk_aws_lambda_ceddda9d.IFunction:
        return typing.cast(_aws_cdk_aws_lambda_ceddda9d.IFunction, jsii.get(self, "function"))

    @builtins.property
    @jsii.member(jsii_name="queue")
    def queue(self) -> _aws_cdk_aws_sqs_ceddda9d.IQueue:
        return typing.cast(_aws_cdk_aws_sqs_ceddda9d.IQueue, jsii.get(self, "queue"))

    @builtins.property
    @jsii.member(jsii_name="deadLetterQueue")
    def dead_letter_queue(self) -> typing.Optional[_aws_cdk_aws_sqs_ceddda9d.Queue]:
        return typing.cast(typing.Optional[_aws_cdk_aws_sqs_ceddda9d.Queue], jsii.get(self, "deadLetterQueue"))

    @builtins.property
    @jsii.member(jsii_name="eventPattern")
    def event_pattern(
        self,
    ) -> typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern]:
        return typing.cast(typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern], jsii.get(self, "eventPattern"))

    @builtins.property
    @jsii.member(jsii_name="targets")
    def targets(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]]:
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]], jsii.get(self, "targets"))


@jsii.data_type(
    jsii_type="aws-ddk-core.SqsToLambdaStageProps",
    jsii_struct_bases=[DataStageProps],
    name_mapping={
        "description": "description",
        "name": "name",
        "alarms_enabled": "alarmsEnabled",
        "batch_size": "batchSize",
        "dlq_enabled": "dlqEnabled",
        "lambda_function": "lambdaFunction",
        "lambda_function_props": "lambdaFunctionProps",
        "max_batching_window": "maxBatchingWindow",
        "max_receive_count": "maxReceiveCount",
        "message_group_id": "messageGroupId",
        "sqs_queue": "sqsQueue",
        "sqs_queue_props": "sqsQueueProps",
    },
)
class SqsToLambdaStageProps(DataStageProps):
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        batch_size: typing.Optional[jsii.Number] = None,
        dlq_enabled: typing.Optional[builtins.bool] = None,
        lambda_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IFunction] = None,
        lambda_function_props: typing.Optional[typing.Union[SqsToLambdaStageFunctionProps, typing.Dict[builtins.str, typing.Any]]] = None,
        max_batching_window: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        max_receive_count: typing.Optional[jsii.Number] = None,
        message_group_id: typing.Optional[builtins.str] = None,
        sqs_queue: typing.Optional[_aws_cdk_aws_sqs_ceddda9d.IQueue] = None,
        sqs_queue_props: typing.Optional[typing.Union[_aws_cdk_aws_sqs_ceddda9d.QueueProps, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param description: 
        :param name: 
        :param alarms_enabled: 
        :param batch_size: 
        :param dlq_enabled: 
        :param lambda_function: 
        :param lambda_function_props: 
        :param max_batching_window: 
        :param max_receive_count: 
        :param message_group_id: 
        :param sqs_queue: 
        :param sqs_queue_props: 
        '''
        if isinstance(lambda_function_props, dict):
            lambda_function_props = SqsToLambdaStageFunctionProps(**lambda_function_props)
        if isinstance(sqs_queue_props, dict):
            sqs_queue_props = _aws_cdk_aws_sqs_ceddda9d.QueueProps(**sqs_queue_props)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6ea408fc3fa64f721e1e8e8f5dba2b0b6340914a77963785a7642a5943b0a04a)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument alarms_enabled", value=alarms_enabled, expected_type=type_hints["alarms_enabled"])
            check_type(argname="argument batch_size", value=batch_size, expected_type=type_hints["batch_size"])
            check_type(argname="argument dlq_enabled", value=dlq_enabled, expected_type=type_hints["dlq_enabled"])
            check_type(argname="argument lambda_function", value=lambda_function, expected_type=type_hints["lambda_function"])
            check_type(argname="argument lambda_function_props", value=lambda_function_props, expected_type=type_hints["lambda_function_props"])
            check_type(argname="argument max_batching_window", value=max_batching_window, expected_type=type_hints["max_batching_window"])
            check_type(argname="argument max_receive_count", value=max_receive_count, expected_type=type_hints["max_receive_count"])
            check_type(argname="argument message_group_id", value=message_group_id, expected_type=type_hints["message_group_id"])
            check_type(argname="argument sqs_queue", value=sqs_queue, expected_type=type_hints["sqs_queue"])
            check_type(argname="argument sqs_queue_props", value=sqs_queue_props, expected_type=type_hints["sqs_queue_props"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if name is not None:
            self._values["name"] = name
        if alarms_enabled is not None:
            self._values["alarms_enabled"] = alarms_enabled
        if batch_size is not None:
            self._values["batch_size"] = batch_size
        if dlq_enabled is not None:
            self._values["dlq_enabled"] = dlq_enabled
        if lambda_function is not None:
            self._values["lambda_function"] = lambda_function
        if lambda_function_props is not None:
            self._values["lambda_function_props"] = lambda_function_props
        if max_batching_window is not None:
            self._values["max_batching_window"] = max_batching_window
        if max_receive_count is not None:
            self._values["max_receive_count"] = max_receive_count
        if message_group_id is not None:
            self._values["message_group_id"] = message_group_id
        if sqs_queue is not None:
            self._values["sqs_queue"] = sqs_queue
        if sqs_queue_props is not None:
            self._values["sqs_queue_props"] = sqs_queue_props

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarms_enabled(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("alarms_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def batch_size(self) -> typing.Optional[jsii.Number]:
        result = self._values.get("batch_size")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dlq_enabled(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("dlq_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def lambda_function(
        self,
    ) -> typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IFunction]:
        result = self._values.get("lambda_function")
        return typing.cast(typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IFunction], result)

    @builtins.property
    def lambda_function_props(self) -> typing.Optional[SqsToLambdaStageFunctionProps]:
        result = self._values.get("lambda_function_props")
        return typing.cast(typing.Optional[SqsToLambdaStageFunctionProps], result)

    @builtins.property
    def max_batching_window(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        result = self._values.get("max_batching_window")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def max_receive_count(self) -> typing.Optional[jsii.Number]:
        result = self._values.get("max_receive_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def message_group_id(self) -> typing.Optional[builtins.str]:
        result = self._values.get("message_group_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sqs_queue(self) -> typing.Optional[_aws_cdk_aws_sqs_ceddda9d.IQueue]:
        result = self._values.get("sqs_queue")
        return typing.cast(typing.Optional[_aws_cdk_aws_sqs_ceddda9d.IQueue], result)

    @builtins.property
    def sqs_queue_props(self) -> typing.Optional[_aws_cdk_aws_sqs_ceddda9d.QueueProps]:
        result = self._values.get("sqs_queue_props")
        return typing.cast(typing.Optional[_aws_cdk_aws_sqs_ceddda9d.QueueProps], 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 "SqsToLambdaStageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class StateMachineStage(
    DataStage,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-ddk-core.StateMachineStage",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
        state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
        state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        state_machine_name: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param additional_role_policy_statements: 
        :param alarms_enabled: 
        :param state_machine_failed_executions_alarm_evaluation_periods: 
        :param state_machine_failed_executions_alarm_threshold: 
        :param state_machine_input: 
        :param state_machine_name: 
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c9ccc4da0d6d8eb11cda39b2839889ebd93235f90bbfbdd93a92a3f816c9fd60)
            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 = StateMachineStageProps(
            additional_role_policy_statements=additional_role_policy_statements,
            alarms_enabled=alarms_enabled,
            state_machine_failed_executions_alarm_evaluation_periods=state_machine_failed_executions_alarm_evaluation_periods,
            state_machine_failed_executions_alarm_threshold=state_machine_failed_executions_alarm_threshold,
            state_machine_input=state_machine_input,
            state_machine_name=state_machine_name,
            description=description,
            name=name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="createStateMachine")
    def _create_state_machine(
        self,
        definition: _aws_cdk_aws_stepfunctions_ceddda9d.IChainable,
        *,
        additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
        state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
        state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        state_machine_name: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> CreateStateMachineResult:
        '''
        :param definition: -
        :param additional_role_policy_statements: 
        :param alarms_enabled: 
        :param state_machine_failed_executions_alarm_evaluation_periods: 
        :param state_machine_failed_executions_alarm_threshold: 
        :param state_machine_input: 
        :param state_machine_name: 
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__642bc4c0673f5b0f2331c42eaeb1c12c1c4fce53646416b8e239dd0bd724b5d2)
            check_type(argname="argument definition", value=definition, expected_type=type_hints["definition"])
        props = StateMachineStageProps(
            additional_role_policy_statements=additional_role_policy_statements,
            alarms_enabled=alarms_enabled,
            state_machine_failed_executions_alarm_evaluation_periods=state_machine_failed_executions_alarm_evaluation_periods,
            state_machine_failed_executions_alarm_threshold=state_machine_failed_executions_alarm_threshold,
            state_machine_input=state_machine_input,
            state_machine_name=state_machine_name,
            description=description,
            name=name,
        )

        return typing.cast(CreateStateMachineResult, jsii.invoke(self, "createStateMachine", [definition, props]))

    @builtins.property
    @jsii.member(jsii_name="stateMachine")
    @abc.abstractmethod
    def state_machine(self) -> _aws_cdk_aws_stepfunctions_ceddda9d.StateMachine:
        ...


class _StateMachineStageProxy(
    StateMachineStage,
    jsii.proxy_for(DataStage), # type: ignore[misc]
):
    @builtins.property
    @jsii.member(jsii_name="stateMachine")
    def state_machine(self) -> _aws_cdk_aws_stepfunctions_ceddda9d.StateMachine:
        return typing.cast(_aws_cdk_aws_stepfunctions_ceddda9d.StateMachine, jsii.get(self, "stateMachine"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, StateMachineStage).__jsii_proxy_class__ = lambda : _StateMachineStageProxy


class AppFlowIngestionStage(
    StateMachineStage,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-ddk-core.AppFlowIngestionStage",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        destination_flow_config: typing.Optional[typing.Union[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.DestinationFlowConfigProperty, typing.Dict[builtins.str, typing.Any]]] = None,
        flow_execution_status_check_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        flow_name: typing.Optional[builtins.str] = None,
        flow_tasks: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.TaskProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        source_flow_config: typing.Optional[typing.Union[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.SourceFlowConfigProperty, typing.Dict[builtins.str, typing.Any]]] = None,
        additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
        state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
        state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        state_machine_name: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param destination_flow_config: 
        :param flow_execution_status_check_period: 
        :param flow_name: 
        :param flow_tasks: 
        :param source_flow_config: 
        :param additional_role_policy_statements: 
        :param alarms_enabled: 
        :param state_machine_failed_executions_alarm_evaluation_periods: 
        :param state_machine_failed_executions_alarm_threshold: 
        :param state_machine_input: 
        :param state_machine_name: 
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__75fdc83ac05ea2b4078c2c89fa4beb028f1353a28c899b42364d275a692f3594)
            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 = AppFlowIngestionStageProps(
            destination_flow_config=destination_flow_config,
            flow_execution_status_check_period=flow_execution_status_check_period,
            flow_name=flow_name,
            flow_tasks=flow_tasks,
            source_flow_config=source_flow_config,
            additional_role_policy_statements=additional_role_policy_statements,
            alarms_enabled=alarms_enabled,
            state_machine_failed_executions_alarm_evaluation_periods=state_machine_failed_executions_alarm_evaluation_periods,
            state_machine_failed_executions_alarm_threshold=state_machine_failed_executions_alarm_threshold,
            state_machine_input=state_machine_input,
            state_machine_name=state_machine_name,
            description=description,
            name=name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @builtins.property
    @jsii.member(jsii_name="flowName")
    def flow_name(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "flowName"))

    @builtins.property
    @jsii.member(jsii_name="flowObject")
    def flow_object(self) -> _aws_cdk_aws_stepfunctions_tasks_ceddda9d.CallAwsService:
        return typing.cast(_aws_cdk_aws_stepfunctions_tasks_ceddda9d.CallAwsService, jsii.get(self, "flowObject"))

    @builtins.property
    @jsii.member(jsii_name="stateMachine")
    def state_machine(self) -> _aws_cdk_aws_stepfunctions_ceddda9d.StateMachine:
        return typing.cast(_aws_cdk_aws_stepfunctions_ceddda9d.StateMachine, jsii.get(self, "stateMachine"))

    @builtins.property
    @jsii.member(jsii_name="eventPattern")
    def event_pattern(
        self,
    ) -> typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern]:
        return typing.cast(typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern], jsii.get(self, "eventPattern"))

    @builtins.property
    @jsii.member(jsii_name="targets")
    def targets(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]]:
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]], jsii.get(self, "targets"))


class AthenaSQLStage(
    StateMachineStage,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-ddk-core.AthenaSQLStage",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        catalog_name: typing.Optional[builtins.str] = None,
        database_name: typing.Optional[builtins.str] = None,
        encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
        encryption_option: typing.Optional[_aws_cdk_aws_stepfunctions_tasks_ceddda9d.EncryptionOption] = None,
        output_location: typing.Optional[typing.Union[_aws_cdk_aws_s3_ceddda9d.Location, typing.Dict[builtins.str, typing.Any]]] = None,
        query_string: typing.Optional[builtins.str] = None,
        query_string_path: typing.Optional[builtins.str] = None,
        work_group: typing.Optional[builtins.str] = None,
        additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
        state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
        state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        state_machine_name: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param catalog_name: 
        :param database_name: 
        :param encryption_key: 
        :param encryption_option: 
        :param output_location: 
        :param query_string: 
        :param query_string_path: 
        :param work_group: 
        :param additional_role_policy_statements: 
        :param alarms_enabled: 
        :param state_machine_failed_executions_alarm_evaluation_periods: 
        :param state_machine_failed_executions_alarm_threshold: 
        :param state_machine_input: 
        :param state_machine_name: 
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__51d1732123dc8ece0c4c19240b905f56cb50227d150f624d8b798a82b65cbe29)
            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 = AthenaToSQLStageProps(
            catalog_name=catalog_name,
            database_name=database_name,
            encryption_key=encryption_key,
            encryption_option=encryption_option,
            output_location=output_location,
            query_string=query_string,
            query_string_path=query_string_path,
            work_group=work_group,
            additional_role_policy_statements=additional_role_policy_statements,
            alarms_enabled=alarms_enabled,
            state_machine_failed_executions_alarm_evaluation_periods=state_machine_failed_executions_alarm_evaluation_periods,
            state_machine_failed_executions_alarm_threshold=state_machine_failed_executions_alarm_threshold,
            state_machine_input=state_machine_input,
            state_machine_name=state_machine_name,
            description=description,
            name=name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @builtins.property
    @jsii.member(jsii_name="stateMachine")
    def state_machine(self) -> _aws_cdk_aws_stepfunctions_ceddda9d.StateMachine:
        return typing.cast(_aws_cdk_aws_stepfunctions_ceddda9d.StateMachine, jsii.get(self, "stateMachine"))

    @builtins.property
    @jsii.member(jsii_name="eventBridgeEventPath")
    def event_bridge_event_path(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "eventBridgeEventPath"))

    @builtins.property
    @jsii.member(jsii_name="eventPattern")
    def event_pattern(
        self,
    ) -> typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern]:
        return typing.cast(typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern], jsii.get(self, "eventPattern"))

    @builtins.property
    @jsii.member(jsii_name="stateMachineInput")
    def state_machine_input(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], jsii.get(self, "stateMachineInput"))

    @builtins.property
    @jsii.member(jsii_name="targets")
    def targets(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]]:
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]], jsii.get(self, "targets"))


class DataBrewTransformStage(
    StateMachineStage,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-ddk-core.DataBrewTransformStage",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        create_job: typing.Optional[builtins.bool] = None,
        database_outputs: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.DatabaseOutputProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        data_catalog_outputs: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.DataCatalogOutputProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        dataset_name: typing.Optional[builtins.str] = None,
        encryption_key_arn: typing.Optional[builtins.str] = None,
        encryption_mode: typing.Optional[builtins.str] = None,
        job_name: typing.Optional[builtins.str] = None,
        job_role_arn: typing.Optional[builtins.str] = None,
        job_sample: typing.Optional[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.JobSampleProperty, typing.Dict[builtins.str, typing.Any]]] = None,
        job_type: typing.Optional[builtins.str] = None,
        log_subscription: typing.Optional[builtins.str] = None,
        max_capacity: typing.Optional[jsii.Number] = None,
        max_retries: typing.Optional[jsii.Number] = None,
        output_location: typing.Optional[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.OutputLocationProperty, typing.Dict[builtins.str, typing.Any]]] = None,
        outputs: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.OutputProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        profile_configuration: typing.Optional[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.ProfileConfigurationProperty, typing.Dict[builtins.str, typing.Any]]] = None,
        project_name: typing.Optional[builtins.str] = None,
        recipe: typing.Optional[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.RecipeProperty, typing.Dict[builtins.str, typing.Any]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_ceddda9d.CfnTag, typing.Dict[builtins.str, typing.Any]]]] = None,
        timeout: typing.Optional[jsii.Number] = None,
        validation_configurations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.ValidationConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
        state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
        state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        state_machine_name: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param create_job: 
        :param database_outputs: 
        :param data_catalog_outputs: 
        :param dataset_name: 
        :param encryption_key_arn: 
        :param encryption_mode: 
        :param job_name: 
        :param job_role_arn: 
        :param job_sample: 
        :param job_type: 
        :param log_subscription: 
        :param max_capacity: 
        :param max_retries: 
        :param output_location: 
        :param outputs: 
        :param profile_configuration: 
        :param project_name: 
        :param recipe: 
        :param tags: 
        :param timeout: 
        :param validation_configurations: 
        :param additional_role_policy_statements: 
        :param alarms_enabled: 
        :param state_machine_failed_executions_alarm_evaluation_periods: 
        :param state_machine_failed_executions_alarm_threshold: 
        :param state_machine_input: 
        :param state_machine_name: 
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a9214d4641d831e11d83d601cf5e13ef25bd3d55977b689c3cefd7aaa9fb0fb5)
            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 = DataBrewTransformStageProps(
            create_job=create_job,
            database_outputs=database_outputs,
            data_catalog_outputs=data_catalog_outputs,
            dataset_name=dataset_name,
            encryption_key_arn=encryption_key_arn,
            encryption_mode=encryption_mode,
            job_name=job_name,
            job_role_arn=job_role_arn,
            job_sample=job_sample,
            job_type=job_type,
            log_subscription=log_subscription,
            max_capacity=max_capacity,
            max_retries=max_retries,
            output_location=output_location,
            outputs=outputs,
            profile_configuration=profile_configuration,
            project_name=project_name,
            recipe=recipe,
            tags=tags,
            timeout=timeout,
            validation_configurations=validation_configurations,
            additional_role_policy_statements=additional_role_policy_statements,
            alarms_enabled=alarms_enabled,
            state_machine_failed_executions_alarm_evaluation_periods=state_machine_failed_executions_alarm_evaluation_periods,
            state_machine_failed_executions_alarm_threshold=state_machine_failed_executions_alarm_threshold,
            state_machine_input=state_machine_input,
            state_machine_name=state_machine_name,
            description=description,
            name=name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @builtins.property
    @jsii.member(jsii_name="createJob")
    def create_job(self) -> builtins.bool:
        return typing.cast(builtins.bool, jsii.get(self, "createJob"))

    @builtins.property
    @jsii.member(jsii_name="jobName")
    def job_name(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "jobName"))

    @builtins.property
    @jsii.member(jsii_name="stateMachine")
    def state_machine(self) -> _aws_cdk_aws_stepfunctions_ceddda9d.StateMachine:
        return typing.cast(_aws_cdk_aws_stepfunctions_ceddda9d.StateMachine, jsii.get(self, "stateMachine"))

    @builtins.property
    @jsii.member(jsii_name="eventPattern")
    def event_pattern(
        self,
    ) -> typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern]:
        return typing.cast(typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern], jsii.get(self, "eventPattern"))

    @builtins.property
    @jsii.member(jsii_name="job")
    def job(self) -> typing.Optional[_aws_cdk_aws_databrew_ceddda9d.CfnJob]:
        return typing.cast(typing.Optional[_aws_cdk_aws_databrew_ceddda9d.CfnJob], jsii.get(self, "job"))

    @builtins.property
    @jsii.member(jsii_name="targets")
    def targets(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]]:
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]], jsii.get(self, "targets"))


class GlueTransformStage(
    StateMachineStage,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-ddk-core.GlueTransformStage",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        crawler_allow_failure: typing.Optional[builtins.bool] = None,
        crawler_name: typing.Optional[builtins.str] = None,
        crawler_props: typing.Optional[typing.Union[_aws_cdk_aws_glue_ceddda9d.CfnCrawlerProps, typing.Dict[builtins.str, typing.Any]]] = None,
        crawler_role: typing.Optional[builtins.str] = None,
        database_name: typing.Optional[builtins.str] = None,
        job_name: typing.Optional[builtins.str] = None,
        job_props: typing.Optional[typing.Union[_aws_cdk_aws_glue_alpha_ce674d29.JobProps, typing.Dict[builtins.str, typing.Any]]] = None,
        job_run_args: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        state_machine_retry_backoff_rate: typing.Optional[jsii.Number] = None,
        state_machine_retry_interval: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        state_machine_retry_max_attempts: typing.Optional[jsii.Number] = None,
        targets: typing.Optional[typing.Union[_aws_cdk_aws_glue_ceddda9d.CfnCrawler.TargetsProperty, typing.Dict[builtins.str, typing.Any]]] = None,
        additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
        state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
        state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        state_machine_name: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param crawler_allow_failure: 
        :param crawler_name: 
        :param crawler_props: 
        :param crawler_role: 
        :param database_name: 
        :param job_name: 
        :param job_props: 
        :param job_run_args: 
        :param state_machine_retry_backoff_rate: 
        :param state_machine_retry_interval: 
        :param state_machine_retry_max_attempts: 
        :param targets: 
        :param additional_role_policy_statements: 
        :param alarms_enabled: 
        :param state_machine_failed_executions_alarm_evaluation_periods: 
        :param state_machine_failed_executions_alarm_threshold: 
        :param state_machine_input: 
        :param state_machine_name: 
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8ddc56c43fee5e5dc6737d945cf18cb6800a5b74340125036ae173083ba761f2)
            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 = GlueTransformStageProps(
            crawler_allow_failure=crawler_allow_failure,
            crawler_name=crawler_name,
            crawler_props=crawler_props,
            crawler_role=crawler_role,
            database_name=database_name,
            job_name=job_name,
            job_props=job_props,
            job_run_args=job_run_args,
            state_machine_retry_backoff_rate=state_machine_retry_backoff_rate,
            state_machine_retry_interval=state_machine_retry_interval,
            state_machine_retry_max_attempts=state_machine_retry_max_attempts,
            targets=targets,
            additional_role_policy_statements=additional_role_policy_statements,
            alarms_enabled=alarms_enabled,
            state_machine_failed_executions_alarm_evaluation_periods=state_machine_failed_executions_alarm_evaluation_periods,
            state_machine_failed_executions_alarm_threshold=state_machine_failed_executions_alarm_threshold,
            state_machine_input=state_machine_input,
            state_machine_name=state_machine_name,
            description=description,
            name=name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @builtins.property
    @jsii.member(jsii_name="glueJob")
    def glue_job(self) -> _aws_cdk_aws_glue_alpha_ce674d29.IJob:
        return typing.cast(_aws_cdk_aws_glue_alpha_ce674d29.IJob, jsii.get(self, "glueJob"))

    @builtins.property
    @jsii.member(jsii_name="stateMachine")
    def state_machine(self) -> _aws_cdk_aws_stepfunctions_ceddda9d.StateMachine:
        return typing.cast(_aws_cdk_aws_stepfunctions_ceddda9d.StateMachine, jsii.get(self, "stateMachine"))

    @builtins.property
    @jsii.member(jsii_name="crawler")
    def crawler(self) -> typing.Optional[_aws_cdk_aws_glue_ceddda9d.CfnCrawler]:
        return typing.cast(typing.Optional[_aws_cdk_aws_glue_ceddda9d.CfnCrawler], jsii.get(self, "crawler"))

    @builtins.property
    @jsii.member(jsii_name="eventPattern")
    def event_pattern(
        self,
    ) -> typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern]:
        return typing.cast(typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern], jsii.get(self, "eventPattern"))

    @builtins.property
    @jsii.member(jsii_name="targets")
    def targets(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]]:
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]], jsii.get(self, "targets"))


class RedshiftDataApiStage(
    StateMachineStage,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-ddk-core.RedshiftDataApiStage",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        redshift_cluster_identifier: builtins.str,
        sql_statements: typing.Sequence[builtins.str],
        database_name: typing.Optional[builtins.str] = None,
        database_user: typing.Optional[builtins.str] = None,
        polling_time: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
        state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
        state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        state_machine_name: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param redshift_cluster_identifier: 
        :param sql_statements: 
        :param database_name: 
        :param database_user: 
        :param polling_time: 
        :param additional_role_policy_statements: 
        :param alarms_enabled: 
        :param state_machine_failed_executions_alarm_evaluation_periods: 
        :param state_machine_failed_executions_alarm_threshold: 
        :param state_machine_input: 
        :param state_machine_name: 
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2e1a2de894e37c9f2da01cc73a49a2d2fe9ec89a86ba3d42531baaa26002a1a7)
            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 = RedshiftDataApiStageProps(
            redshift_cluster_identifier=redshift_cluster_identifier,
            sql_statements=sql_statements,
            database_name=database_name,
            database_user=database_user,
            polling_time=polling_time,
            additional_role_policy_statements=additional_role_policy_statements,
            alarms_enabled=alarms_enabled,
            state_machine_failed_executions_alarm_evaluation_periods=state_machine_failed_executions_alarm_evaluation_periods,
            state_machine_failed_executions_alarm_threshold=state_machine_failed_executions_alarm_threshold,
            state_machine_input=state_machine_input,
            state_machine_name=state_machine_name,
            description=description,
            name=name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @builtins.property
    @jsii.member(jsii_name="stateMachine")
    def state_machine(self) -> _aws_cdk_aws_stepfunctions_ceddda9d.StateMachine:
        return typing.cast(_aws_cdk_aws_stepfunctions_ceddda9d.StateMachine, jsii.get(self, "stateMachine"))

    @builtins.property
    @jsii.member(jsii_name="eventBridgeEventPath")
    def event_bridge_event_path(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "eventBridgeEventPath"))

    @builtins.property
    @jsii.member(jsii_name="eventPattern")
    def event_pattern(
        self,
    ) -> typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern]:
        return typing.cast(typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern], jsii.get(self, "eventPattern"))

    @builtins.property
    @jsii.member(jsii_name="stateMachineInput")
    def state_machine_input(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], jsii.get(self, "stateMachineInput"))

    @builtins.property
    @jsii.member(jsii_name="targets")
    def targets(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]]:
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]], jsii.get(self, "targets"))


class SnsSqsToLambdaStage(
    SqsToLambdaStage,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-ddk-core.SnsSqsToLambdaStage",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        disable_default_topic_policy: typing.Optional[builtins.bool] = None,
        filter_policy: typing.Optional[typing.Mapping[builtins.str, _aws_cdk_aws_sns_ceddda9d.SubscriptionFilter]] = None,
        raw_message_delivery: typing.Optional[builtins.bool] = None,
        sns_dlq_enabled: typing.Optional[builtins.bool] = None,
        sns_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
        sns_topic_props: typing.Optional[typing.Union[_aws_cdk_aws_sns_ceddda9d.TopicProps, typing.Dict[builtins.str, typing.Any]]] = None,
        batch_size: typing.Optional[jsii.Number] = None,
        dlq_enabled: typing.Optional[builtins.bool] = None,
        lambda_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IFunction] = None,
        lambda_function_props: typing.Optional[typing.Union[SqsToLambdaStageFunctionProps, typing.Dict[builtins.str, typing.Any]]] = None,
        max_batching_window: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        max_receive_count: typing.Optional[jsii.Number] = None,
        message_group_id: typing.Optional[builtins.str] = None,
        sqs_queue: typing.Optional[_aws_cdk_aws_sqs_ceddda9d.IQueue] = None,
        sqs_queue_props: typing.Optional[typing.Union[_aws_cdk_aws_sqs_ceddda9d.QueueProps, typing.Dict[builtins.str, typing.Any]]] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param disable_default_topic_policy: 
        :param filter_policy: 
        :param raw_message_delivery: 
        :param sns_dlq_enabled: 
        :param sns_topic: 
        :param sns_topic_props: 
        :param batch_size: 
        :param dlq_enabled: 
        :param lambda_function: 
        :param lambda_function_props: 
        :param max_batching_window: 
        :param max_receive_count: 
        :param message_group_id: 
        :param sqs_queue: 
        :param sqs_queue_props: 
        :param alarms_enabled: 
        :param description: 
        :param name: 
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f1f6169c1775457f18465db8ac58b6e948ab3cee732db9fb369eb57e96e8b7ef)
            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 = SnsToLambdaStageProps(
            disable_default_topic_policy=disable_default_topic_policy,
            filter_policy=filter_policy,
            raw_message_delivery=raw_message_delivery,
            sns_dlq_enabled=sns_dlq_enabled,
            sns_topic=sns_topic,
            sns_topic_props=sns_topic_props,
            batch_size=batch_size,
            dlq_enabled=dlq_enabled,
            lambda_function=lambda_function,
            lambda_function_props=lambda_function_props,
            max_batching_window=max_batching_window,
            max_receive_count=max_receive_count,
            message_group_id=message_group_id,
            sqs_queue=sqs_queue,
            sqs_queue_props=sqs_queue_props,
            alarms_enabled=alarms_enabled,
            description=description,
            name=name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @builtins.property
    @jsii.member(jsii_name="topic")
    def topic(self) -> _aws_cdk_aws_sns_ceddda9d.ITopic:
        return typing.cast(_aws_cdk_aws_sns_ceddda9d.ITopic, jsii.get(self, "topic"))

    @builtins.property
    @jsii.member(jsii_name="eventPattern")
    def event_pattern(
        self,
    ) -> typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern]:
        return typing.cast(typing.Optional[_aws_cdk_aws_events_ceddda9d.EventPattern], jsii.get(self, "eventPattern"))

    @builtins.property
    @jsii.member(jsii_name="snsDeadLetterQueue")
    def sns_dead_letter_queue(self) -> typing.Optional[_aws_cdk_aws_sqs_ceddda9d.Queue]:
        return typing.cast(typing.Optional[_aws_cdk_aws_sqs_ceddda9d.Queue], jsii.get(self, "snsDeadLetterQueue"))

    @builtins.property
    @jsii.member(jsii_name="targets")
    def targets(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]]:
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_events_ceddda9d.IRuleTarget]], jsii.get(self, "targets"))


@jsii.data_type(
    jsii_type="aws-ddk-core.SnsToLambdaStageProps",
    jsii_struct_bases=[SqsToLambdaStageProps],
    name_mapping={
        "description": "description",
        "name": "name",
        "alarms_enabled": "alarmsEnabled",
        "batch_size": "batchSize",
        "dlq_enabled": "dlqEnabled",
        "lambda_function": "lambdaFunction",
        "lambda_function_props": "lambdaFunctionProps",
        "max_batching_window": "maxBatchingWindow",
        "max_receive_count": "maxReceiveCount",
        "message_group_id": "messageGroupId",
        "sqs_queue": "sqsQueue",
        "sqs_queue_props": "sqsQueueProps",
        "disable_default_topic_policy": "disableDefaultTopicPolicy",
        "filter_policy": "filterPolicy",
        "raw_message_delivery": "rawMessageDelivery",
        "sns_dlq_enabled": "snsDlqEnabled",
        "sns_topic": "snsTopic",
        "sns_topic_props": "snsTopicProps",
    },
)
class SnsToLambdaStageProps(SqsToLambdaStageProps):
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
        alarms_enabled: typing.Optional[builtins.bool] = None,
        batch_size: typing.Optional[jsii.Number] = None,
        dlq_enabled: typing.Optional[builtins.bool] = None,
        lambda_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IFunction] = None,
        lambda_function_props: typing.Optional[typing.Union[SqsToLambdaStageFunctionProps, typing.Dict[builtins.str, typing.Any]]] = None,
        max_batching_window: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        max_receive_count: typing.Optional[jsii.Number] = None,
        message_group_id: typing.Optional[builtins.str] = None,
        sqs_queue: typing.Optional[_aws_cdk_aws_sqs_ceddda9d.IQueue] = None,
        sqs_queue_props: typing.Optional[typing.Union[_aws_cdk_aws_sqs_ceddda9d.QueueProps, typing.Dict[builtins.str, typing.Any]]] = None,
        disable_default_topic_policy: typing.Optional[builtins.bool] = None,
        filter_policy: typing.Optional[typing.Mapping[builtins.str, _aws_cdk_aws_sns_ceddda9d.SubscriptionFilter]] = None,
        raw_message_delivery: typing.Optional[builtins.bool] = None,
        sns_dlq_enabled: typing.Optional[builtins.bool] = None,
        sns_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
        sns_topic_props: typing.Optional[typing.Union[_aws_cdk_aws_sns_ceddda9d.TopicProps, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param description: 
        :param name: 
        :param alarms_enabled: 
        :param batch_size: 
        :param dlq_enabled: 
        :param lambda_function: 
        :param lambda_function_props: 
        :param max_batching_window: 
        :param max_receive_count: 
        :param message_group_id: 
        :param sqs_queue: 
        :param sqs_queue_props: 
        :param disable_default_topic_policy: 
        :param filter_policy: 
        :param raw_message_delivery: 
        :param sns_dlq_enabled: 
        :param sns_topic: 
        :param sns_topic_props: 
        '''
        if isinstance(lambda_function_props, dict):
            lambda_function_props = SqsToLambdaStageFunctionProps(**lambda_function_props)
        if isinstance(sqs_queue_props, dict):
            sqs_queue_props = _aws_cdk_aws_sqs_ceddda9d.QueueProps(**sqs_queue_props)
        if isinstance(sns_topic_props, dict):
            sns_topic_props = _aws_cdk_aws_sns_ceddda9d.TopicProps(**sns_topic_props)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b1ced712cbd6acd872556813dd7192431ee7539b2ab066fa0aafd950cc7268b0)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument alarms_enabled", value=alarms_enabled, expected_type=type_hints["alarms_enabled"])
            check_type(argname="argument batch_size", value=batch_size, expected_type=type_hints["batch_size"])
            check_type(argname="argument dlq_enabled", value=dlq_enabled, expected_type=type_hints["dlq_enabled"])
            check_type(argname="argument lambda_function", value=lambda_function, expected_type=type_hints["lambda_function"])
            check_type(argname="argument lambda_function_props", value=lambda_function_props, expected_type=type_hints["lambda_function_props"])
            check_type(argname="argument max_batching_window", value=max_batching_window, expected_type=type_hints["max_batching_window"])
            check_type(argname="argument max_receive_count", value=max_receive_count, expected_type=type_hints["max_receive_count"])
            check_type(argname="argument message_group_id", value=message_group_id, expected_type=type_hints["message_group_id"])
            check_type(argname="argument sqs_queue", value=sqs_queue, expected_type=type_hints["sqs_queue"])
            check_type(argname="argument sqs_queue_props", value=sqs_queue_props, expected_type=type_hints["sqs_queue_props"])
            check_type(argname="argument disable_default_topic_policy", value=disable_default_topic_policy, expected_type=type_hints["disable_default_topic_policy"])
            check_type(argname="argument filter_policy", value=filter_policy, expected_type=type_hints["filter_policy"])
            check_type(argname="argument raw_message_delivery", value=raw_message_delivery, expected_type=type_hints["raw_message_delivery"])
            check_type(argname="argument sns_dlq_enabled", value=sns_dlq_enabled, expected_type=type_hints["sns_dlq_enabled"])
            check_type(argname="argument sns_topic", value=sns_topic, expected_type=type_hints["sns_topic"])
            check_type(argname="argument sns_topic_props", value=sns_topic_props, expected_type=type_hints["sns_topic_props"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if name is not None:
            self._values["name"] = name
        if alarms_enabled is not None:
            self._values["alarms_enabled"] = alarms_enabled
        if batch_size is not None:
            self._values["batch_size"] = batch_size
        if dlq_enabled is not None:
            self._values["dlq_enabled"] = dlq_enabled
        if lambda_function is not None:
            self._values["lambda_function"] = lambda_function
        if lambda_function_props is not None:
            self._values["lambda_function_props"] = lambda_function_props
        if max_batching_window is not None:
            self._values["max_batching_window"] = max_batching_window
        if max_receive_count is not None:
            self._values["max_receive_count"] = max_receive_count
        if message_group_id is not None:
            self._values["message_group_id"] = message_group_id
        if sqs_queue is not None:
            self._values["sqs_queue"] = sqs_queue
        if sqs_queue_props is not None:
            self._values["sqs_queue_props"] = sqs_queue_props
        if disable_default_topic_policy is not None:
            self._values["disable_default_topic_policy"] = disable_default_topic_policy
        if filter_policy is not None:
            self._values["filter_policy"] = filter_policy
        if raw_message_delivery is not None:
            self._values["raw_message_delivery"] = raw_message_delivery
        if sns_dlq_enabled is not None:
            self._values["sns_dlq_enabled"] = sns_dlq_enabled
        if sns_topic is not None:
            self._values["sns_topic"] = sns_topic
        if sns_topic_props is not None:
            self._values["sns_topic_props"] = sns_topic_props

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        result = self._values.get("name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarms_enabled(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("alarms_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def batch_size(self) -> typing.Optional[jsii.Number]:
        result = self._values.get("batch_size")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dlq_enabled(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("dlq_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def lambda_function(
        self,
    ) -> typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IFunction]:
        result = self._values.get("lambda_function")
        return typing.cast(typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IFunction], result)

    @builtins.property
    def lambda_function_props(self) -> typing.Optional[SqsToLambdaStageFunctionProps]:
        result = self._values.get("lambda_function_props")
        return typing.cast(typing.Optional[SqsToLambdaStageFunctionProps], result)

    @builtins.property
    def max_batching_window(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        result = self._values.get("max_batching_window")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def max_receive_count(self) -> typing.Optional[jsii.Number]:
        result = self._values.get("max_receive_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def message_group_id(self) -> typing.Optional[builtins.str]:
        result = self._values.get("message_group_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sqs_queue(self) -> typing.Optional[_aws_cdk_aws_sqs_ceddda9d.IQueue]:
        result = self._values.get("sqs_queue")
        return typing.cast(typing.Optional[_aws_cdk_aws_sqs_ceddda9d.IQueue], result)

    @builtins.property
    def sqs_queue_props(self) -> typing.Optional[_aws_cdk_aws_sqs_ceddda9d.QueueProps]:
        result = self._values.get("sqs_queue_props")
        return typing.cast(typing.Optional[_aws_cdk_aws_sqs_ceddda9d.QueueProps], result)

    @builtins.property
    def disable_default_topic_policy(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("disable_default_topic_policy")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def filter_policy(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, _aws_cdk_aws_sns_ceddda9d.SubscriptionFilter]]:
        result = self._values.get("filter_policy")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, _aws_cdk_aws_sns_ceddda9d.SubscriptionFilter]], result)

    @builtins.property
    def raw_message_delivery(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("raw_message_delivery")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def sns_dlq_enabled(self) -> typing.Optional[builtins.bool]:
        result = self._values.get("sns_dlq_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def sns_topic(self) -> typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic]:
        result = self._values.get("sns_topic")
        return typing.cast(typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic], result)

    @builtins.property
    def sns_topic_props(self) -> typing.Optional[_aws_cdk_aws_sns_ceddda9d.TopicProps]:
        result = self._values.get("sns_topic_props")
        return typing.cast(typing.Optional[_aws_cdk_aws_sns_ceddda9d.TopicProps], 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 "SnsToLambdaStageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


__all__ = [
    "AddApplicationStageProps",
    "AddApplicationWaveProps",
    "AddCustomStageProps",
    "AddNotificationsProps",
    "AddRuleProps",
    "AddSecurityLintStageProps",
    "AddStageProps",
    "AddTestStageProps",
    "AdditionalPipelineProps",
    "AlarmProps",
    "AppFlowIngestionStage",
    "AppFlowIngestionStageProps",
    "AthenaSQLStage",
    "AthenaToSQLStageProps",
    "BaseStack",
    "BaseStackProps",
    "CICDActions",
    "CICDPipelineStack",
    "CICDPipelineStackProps",
    "CodeArtifactPublishActionProps",
    "CodeCommitSourceActionProps",
    "Configuration",
    "Configurator",
    "CreateStateMachineResult",
    "DataBrewTransformStage",
    "DataBrewTransformStageProps",
    "DataPipeline",
    "DataPipelineProps",
    "DataStage",
    "DataStageProps",
    "DeliveryStreamProps",
    "EnvironmentConfiguration",
    "EnvironmentResult",
    "EventStage",
    "EventStageProps",
    "FirehoseToS3Stage",
    "FirehoseToS3StageProps",
    "GetEnvConfigProps",
    "GetEnvironmentProps",
    "GetSynthActionProps",
    "GetTagsProps",
    "GlueFactory",
    "GlueTransformStage",
    "GlueTransformStageProps",
    "KmsFactory",
    "PermissionsBoundaryProps",
    "RedshiftDataApiStage",
    "RedshiftDataApiStageProps",
    "S3EventStage",
    "S3EventStageProps",
    "S3Factory",
    "SnsFactory",
    "SnsSqsToLambdaStage",
    "SnsToLambdaStageProps",
    "SourceActionProps",
    "SqsToLambdaStage",
    "SqsToLambdaStageFunctionProps",
    "SqsToLambdaStageProps",
    "Stage",
    "StageProps",
    "StateMachineStage",
    "StateMachineStageProps",
    "SynthActionProps",
]

publication.publish()

def _typecheckingstub__b76c36dbcfdd4e997564efc9be54eb407b35cd3e027b00901b31d379e392170e(
    *,
    stage: _aws_cdk_ceddda9d.Stage,
    stage_id: builtins.str,
    manual_approvals: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1c5ca54834b066a96cdaae8f32086d4638af32527e6bdd7356e96d6b16db8c0d(
    *,
    stage_id: builtins.str,
    stages: typing.Sequence[_aws_cdk_ceddda9d.Stage],
    manual_approvals: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8660c7ffe37e5e521438a6f05e109d7d73960491ec724c71005fa435cb1ba0cb(
    *,
    stage_name: builtins.str,
    steps: typing.Sequence[_aws_cdk_pipelines_ceddda9d.Step],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f6b36a0552668c2be6f5870fa1fc235676fcd1d8e1633ffdcd8fe2ab50a5eb9c(
    *,
    notification_rule: typing.Optional[_aws_cdk_aws_codestarnotifications_ceddda9d.NotificationRule] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dc4d3cd99b8129cd1e9e86879e1aa4a9e7d0340f69bb169e136c78c563e397f5(
    *,
    event_pattern: typing.Optional[typing.Union[_aws_cdk_aws_events_ceddda9d.EventPattern, typing.Dict[builtins.str, typing.Any]]] = None,
    event_targets: typing.Optional[typing.Sequence[_aws_cdk_aws_events_ceddda9d.IRuleTarget]] = None,
    id: typing.Optional[builtins.str] = None,
    override_rule: typing.Optional[_aws_cdk_aws_events_ceddda9d.IRule] = None,
    rule_name: typing.Optional[builtins.str] = None,
    schedule: typing.Optional[_aws_cdk_aws_events_ceddda9d.Schedule] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f5c6a426f2b47035ddfb61265fb0fc5f914c183c57db8be19fd6917fe3755000(
    *,
    cloud_assembly_file_set: typing.Optional[_aws_cdk_pipelines_ceddda9d.IFileSetProducer] = None,
    stage_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c40909713474fb0ac5879649d02b6b9b99cca8e07cc03cfb0ee3a2161cabd53f(
    *,
    stage: Stage,
    override_rule: typing.Optional[_aws_cdk_aws_events_ceddda9d.IRule] = None,
    rule_name: typing.Optional[builtins.str] = None,
    schedule: typing.Optional[_aws_cdk_aws_events_ceddda9d.Schedule] = None,
    skip_rule: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0efd164879f28724d26fec5d40738d32540d827f1e7d46271d569f72a3a0a21f(
    *,
    cloud_assembly_file_set: typing.Optional[_aws_cdk_pipelines_ceddda9d.IFileSetProducer] = None,
    commands: typing.Optional[typing.Sequence[builtins.str]] = None,
    stage_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__34c4dbaccc767dfa14746a2df4a90bdbf9d6318afb10cc0e8809c95f4447414b(
    *,
    asset_publishing_code_build_defaults: typing.Optional[typing.Union[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    cli_version: typing.Optional[builtins.str] = None,
    code_build_defaults: typing.Optional[typing.Union[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    code_pipeline: typing.Optional[_aws_cdk_aws_codepipeline_ceddda9d.Pipeline] = None,
    docker_credentials: typing.Optional[typing.Sequence[_aws_cdk_pipelines_ceddda9d.DockerCredential]] = None,
    docker_enabled_for_self_mutation: typing.Optional[builtins.bool] = None,
    docker_enabled_for_synth: typing.Optional[builtins.bool] = None,
    publish_assets_in_parallel: typing.Optional[builtins.bool] = None,
    reuse_cross_region_support_stacks: typing.Optional[builtins.bool] = None,
    self_mutation: typing.Optional[builtins.bool] = None,
    self_mutation_code_build_defaults: typing.Optional[typing.Union[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    synth_code_build_defaults: typing.Optional[typing.Union[_aws_cdk_pipelines_ceddda9d.CodeBuildOptions, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9739513f93590856f8f02851ab5bfe24bf3c845f3e37410565b3668ac8406da2(
    *,
    metric: _aws_cdk_aws_cloudwatch_ceddda9d.IMetric,
    comparison_operator: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    threshold: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__403bc1fd4d529dd1acdcfdf6824076a7e78329d131f442981f447f8f5298a7cc(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    config: typing.Optional[typing.Union[builtins.str, typing.Union[Configuration, typing.Dict[builtins.str, typing.Any]]]] = None,
    environment_id: typing.Optional[builtins.str] = None,
    permissions_boundary_arn: typing.Optional[builtins.str] = None,
    analytics_reporting: typing.Optional[builtins.bool] = None,
    cross_region_references: typing.Optional[builtins.bool] = None,
    description: typing.Optional[builtins.str] = None,
    env: typing.Optional[typing.Union[_aws_cdk_ceddda9d.Environment, typing.Dict[builtins.str, typing.Any]]] = None,
    permissions_boundary: typing.Optional[_aws_cdk_ceddda9d.PermissionsBoundary] = None,
    stack_name: typing.Optional[builtins.str] = None,
    synthesizer: typing.Optional[_aws_cdk_ceddda9d.IStackSynthesizer] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    termination_protection: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c52c78b6e97cce4b370cb75d9552fff81495ba02218c70f1c8947488c2c0604a(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    environment_id: typing.Optional[builtins.str] = None,
    prefix: typing.Optional[builtins.str] = None,
    qualifier: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a429ca722d1fec889b8120d065d6c339e922faac9a9e70454e565500ff82514c(
    *,
    analytics_reporting: typing.Optional[builtins.bool] = None,
    cross_region_references: typing.Optional[builtins.bool] = None,
    description: typing.Optional[builtins.str] = None,
    env: typing.Optional[typing.Union[_aws_cdk_ceddda9d.Environment, typing.Dict[builtins.str, typing.Any]]] = None,
    permissions_boundary: typing.Optional[_aws_cdk_ceddda9d.PermissionsBoundary] = None,
    stack_name: typing.Optional[builtins.str] = None,
    synthesizer: typing.Optional[_aws_cdk_ceddda9d.IStackSynthesizer] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    termination_protection: typing.Optional[builtins.bool] = None,
    config: typing.Optional[typing.Union[builtins.str, typing.Union[Configuration, typing.Dict[builtins.str, typing.Any]]]] = None,
    environment_id: typing.Optional[builtins.str] = None,
    permissions_boundary_arn: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fab9ea5d8746e6c137eb1d92124b75da65dab030241ebf0002427b6ad8676aa2(
    code_pipeline_source: _aws_cdk_pipelines_ceddda9d.CodePipelineSource,
    stage_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ebe600cfab48179494151cd33416082a904aa73df681b93f5266545008838275(
    file_set_producer: _aws_cdk_pipelines_ceddda9d.IFileSetProducer,
    stage_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__203dfc08c6a839aacb072ea162bb03ae398d33f465cc8723ee83f36c65bf9fc8(
    partition: builtins.str,
    region: builtins.str,
    account: builtins.str,
    codeartifact_repository: builtins.str,
    codeartifact_domain: builtins.str,
    codeartifact_domain_owner: builtins.str,
    code_pipeline_source: typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipelineSource] = None,
    role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__299e24a53c04aec79676a22aae09e979fe6ffa8af8ec8306445500237732a145(
    scope: _constructs_77d1e7e8.Construct,
    *,
    branch: builtins.str,
    repository_name: builtins.str,
    props: typing.Optional[typing.Union[_aws_cdk_pipelines_ceddda9d.ConnectionSourceOptions, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__906b3057114921fd5b8c18404d27778ac3f64ce364e27565682c6ab1bac71b7b(
    file_set_producer: _aws_cdk_pipelines_ceddda9d.IFileSetProducer,
    commands: typing.Optional[typing.Sequence[builtins.str]] = None,
    install_commands: typing.Optional[typing.Sequence[builtins.str]] = None,
    stage_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2a4f7374970c6409060af558e7802348870a4c4a3b9f9232e789f1488d18fb90(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    cdk_language: typing.Optional[builtins.str] = None,
    pipeline_name: typing.Optional[builtins.str] = None,
    config: typing.Optional[typing.Union[builtins.str, typing.Union[Configuration, typing.Dict[builtins.str, typing.Any]]]] = None,
    environment_id: typing.Optional[builtins.str] = None,
    permissions_boundary_arn: typing.Optional[builtins.str] = None,
    analytics_reporting: typing.Optional[builtins.bool] = None,
    cross_region_references: typing.Optional[builtins.bool] = None,
    description: typing.Optional[builtins.str] = None,
    env: typing.Optional[typing.Union[_aws_cdk_ceddda9d.Environment, typing.Dict[builtins.str, typing.Any]]] = None,
    permissions_boundary: typing.Optional[_aws_cdk_ceddda9d.PermissionsBoundary] = None,
    stack_name: typing.Optional[builtins.str] = None,
    synthesizer: typing.Optional[_aws_cdk_ceddda9d.IStackSynthesizer] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    termination_protection: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0068433bd751f33d982df797ea7caafaf7cffac6096fcfa31b631eb939dd331b(
    value: typing.Optional[_aws_cdk_aws_codestarnotifications_ceddda9d.NotificationRule],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9e242ec0edda32ab650513e5c858717f596009d201ebe6c35d192b13bb37b46e(
    value: typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipeline],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bdd6e87a9d4eea532d3b53339bd619a881413d8b48bab8ceb6116633e65f946d(
    value: typing.Optional[_aws_cdk_aws_kms_ceddda9d.CfnKey],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__19397f9a8bd0b90a5f185ea4729b0b19930bbfb902f228f2537c616170569bf6(
    value: typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipelineSource],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ae2239ce5199560ebc5f2e8f3ab6392af34c4678da2fdeb67265c0f37277507b(
    value: typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildStep],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a92abb1f3b57ec36ef721160ab799be2851ede5d3e872162fc75be713f4d3293(
    *,
    analytics_reporting: typing.Optional[builtins.bool] = None,
    cross_region_references: typing.Optional[builtins.bool] = None,
    description: typing.Optional[builtins.str] = None,
    env: typing.Optional[typing.Union[_aws_cdk_ceddda9d.Environment, typing.Dict[builtins.str, typing.Any]]] = None,
    permissions_boundary: typing.Optional[_aws_cdk_ceddda9d.PermissionsBoundary] = None,
    stack_name: typing.Optional[builtins.str] = None,
    synthesizer: typing.Optional[_aws_cdk_ceddda9d.IStackSynthesizer] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    termination_protection: typing.Optional[builtins.bool] = None,
    config: typing.Optional[typing.Union[builtins.str, typing.Union[Configuration, typing.Dict[builtins.str, typing.Any]]]] = None,
    environment_id: typing.Optional[builtins.str] = None,
    permissions_boundary_arn: typing.Optional[builtins.str] = None,
    cdk_language: typing.Optional[builtins.str] = None,
    pipeline_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c35f21eb6e1a4595459d5a4102a340db464f6d6da23770e16d40eca5d3e00623(
    *,
    account: builtins.str,
    codeartifact_domain: builtins.str,
    codeartifact_domain_owner: builtins.str,
    codeartifact_repository: builtins.str,
    partition: builtins.str,
    region: builtins.str,
    code_pipeline_source: typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipelineSource] = None,
    role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d8379be0808b59cd840396438fecd2826772ffc3dbcfeaf5175ccf01b988d69b(
    *,
    branch: builtins.str,
    repository_name: builtins.str,
    props: typing.Optional[typing.Union[_aws_cdk_pipelines_ceddda9d.ConnectionSourceOptions, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__daeed9e6cb5e50c39b922933d297c173f25183423bf700dfd9f8b0fe3765c923(
    *,
    environments: typing.Mapping[builtins.str, typing.Union[EnvironmentConfiguration, typing.Dict[builtins.str, typing.Any]]],
    account: typing.Optional[builtins.str] = None,
    bootstrap: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    ddk_bootstrap_config_key: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__83dd06108e5a02547d07299060f92123340b3d7ec7e9e6f36a8e28ce02b22a22(
    scope: _constructs_77d1e7e8.Construct,
    config: typing.Union[builtins.str, typing.Union[Configuration, typing.Dict[builtins.str, typing.Any]]],
    environment_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ce369044fa737e8a329b15db41cbef0ecf3e52cea663d9bd55b6edfe486a7705(
    attribute: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5ebebaeeabeb2e14afe10bb65476a72e653389f44163949f819c5b260fc48e7c(
    scope: _constructs_77d1e7e8.Construct,
    tags: typing.Mapping[builtins.str, builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a42d01fb82a6fe17fa9b9b89a21fb52b88b8267a8d48f866ab150cb834952324(
    *,
    event_pattern: typing.Union[_aws_cdk_aws_events_ceddda9d.EventPattern, typing.Dict[builtins.str, typing.Any]],
    state_machine: _aws_cdk_aws_stepfunctions_ceddda9d.StateMachine,
    targets: typing.Sequence[_aws_cdk_aws_events_ceddda9d.IRuleTarget],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__020d69ac62c8be050bbf68165b37eefae84c4185726ff175a8444e0c59df78df(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0261b3bfb9d75b19f131b94fdac46b066b26e0543adf83caf2f9ff8436e7fc80(
    notifications_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__946287dcda6fcab40d64fc9e8f72a5917de6ace9c417f850f53a1418c864067d(
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ef7997fe1d9215e0814459fdbbb95740e62a7f0437cd0df0dcd43ac255b163e4(
    *,
    delivery_stream_name: typing.Optional[builtins.str] = None,
    destinations: typing.Optional[typing.Sequence[_aws_cdk_aws_kinesisfirehose_alpha_30daaf29.IDestination]] = None,
    encryption: typing.Optional[_aws_cdk_aws_kinesisfirehose_alpha_30daaf29.StreamEncryption] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey] = None,
    role: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole] = None,
    source_stream: typing.Optional[_aws_cdk_aws_kinesis_ceddda9d.IStream] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cf306c436463dcb56197f32e9c4793604595ef2ca8f42b2d72de058d5806870c(
    *,
    account: typing.Optional[builtins.str] = None,
    bootstrap: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    region: typing.Optional[builtins.str] = None,
    resources: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c2515674b45134976862352edd7f3a4f56dddd10e860df69a14d633b55dfe768(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__392d4bf9e0a3416c4cbfe2cfcca884cc2b98f96b99a23a03e386497b6cfd2fef(
    *,
    config_path: builtins.str,
    environment_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f1d1864ebb63e794b66b601804d8a186ccc2fe70e5c1aeea9def8ecd1ab83dde(
    *,
    config_path: builtins.str,
    environment_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b411e230303f93f36fe42f88f3ae59e51d4746a608fa21c8fe560bb5fe18a352(
    *,
    account: typing.Optional[builtins.str] = None,
    additional_install_commands: typing.Optional[typing.Sequence[builtins.str]] = None,
    cdk_version: typing.Optional[builtins.str] = None,
    codeartifact_domain: typing.Optional[builtins.str] = None,
    codeartifact_domain_owner: typing.Optional[builtins.str] = None,
    codeartifact_repository: typing.Optional[builtins.str] = None,
    code_pipeline_source: typing.Optional[_aws_cdk_pipelines_ceddda9d.IFileSetProducer] = None,
    partition: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f80411a398b3a95cafcc083fedf809e35c9f9d3c872682fa20c2c416251da930(
    *,
    config_path: builtins.str,
    environment_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__de56c47dda07ed1c4eda1133b7152caa819140d8ea5277eaf41f2802c2c16bfd(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    executable: _aws_cdk_aws_glue_alpha_ce674d29.JobExecutable,
    connections: typing.Optional[typing.Sequence[_aws_cdk_aws_glue_alpha_ce674d29.IConnection]] = None,
    continuous_logging: typing.Optional[typing.Union[_aws_cdk_aws_glue_alpha_ce674d29.ContinuousLoggingProps, typing.Dict[builtins.str, typing.Any]]] = None,
    default_arguments: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    description: typing.Optional[builtins.str] = None,
    enable_profiling_metrics: typing.Optional[builtins.bool] = None,
    job_name: typing.Optional[builtins.str] = None,
    max_capacity: typing.Optional[jsii.Number] = None,
    max_concurrent_runs: typing.Optional[jsii.Number] = None,
    max_retries: typing.Optional[jsii.Number] = None,
    notify_delay_after: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    role: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole] = None,
    security_configuration: typing.Optional[_aws_cdk_aws_glue_alpha_ce674d29.ISecurityConfiguration] = None,
    spark_ui: typing.Optional[typing.Union[_aws_cdk_aws_glue_alpha_ce674d29.SparkUIProps, typing.Dict[builtins.str, typing.Any]]] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    worker_count: typing.Optional[jsii.Number] = None,
    worker_type: typing.Optional[_aws_cdk_aws_glue_alpha_ce674d29.WorkerType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a14864520200528bc5a9369b081737198f4eb3e97462ea981304386c09050813(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    admins: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.IPrincipal]] = None,
    alias: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    enabled: typing.Optional[builtins.bool] = None,
    enable_key_rotation: typing.Optional[builtins.bool] = None,
    key_spec: typing.Optional[_aws_cdk_aws_kms_ceddda9d.KeySpec] = None,
    key_usage: typing.Optional[_aws_cdk_aws_kms_ceddda9d.KeyUsage] = None,
    pending_window: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    policy: typing.Optional[_aws_cdk_aws_iam_ceddda9d.PolicyDocument] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__efd5392745ac5f11de7c7110e4c4c8cc4060becd6944d345396c27f2c82152b4(
    *,
    environment_id: typing.Optional[builtins.str] = None,
    prefix: typing.Optional[builtins.str] = None,
    qualifier: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__302aa44a04efd7039f32314924ad83f7735955102f1c3d6163fb082aae834c76(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    access_control: typing.Optional[_aws_cdk_aws_s3_ceddda9d.BucketAccessControl] = None,
    auto_delete_objects: typing.Optional[builtins.bool] = None,
    block_public_access: typing.Optional[_aws_cdk_aws_s3_ceddda9d.BlockPublicAccess] = None,
    bucket_key_enabled: typing.Optional[builtins.bool] = None,
    bucket_name: typing.Optional[builtins.str] = None,
    cors: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_s3_ceddda9d.CorsRule, typing.Dict[builtins.str, typing.Any]]]] = None,
    encryption: typing.Optional[_aws_cdk_aws_s3_ceddda9d.BucketEncryption] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey] = None,
    enforce_ssl: typing.Optional[builtins.bool] = None,
    event_bridge_enabled: typing.Optional[builtins.bool] = None,
    intelligent_tiering_configurations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_s3_ceddda9d.IntelligentTieringConfiguration, typing.Dict[builtins.str, typing.Any]]]] = None,
    inventories: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_s3_ceddda9d.Inventory, typing.Dict[builtins.str, typing.Any]]]] = None,
    lifecycle_rules: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_s3_ceddda9d.LifecycleRule, typing.Dict[builtins.str, typing.Any]]]] = None,
    metrics: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_s3_ceddda9d.BucketMetrics, typing.Dict[builtins.str, typing.Any]]]] = None,
    notifications_handler_role: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole] = None,
    object_lock_default_retention: typing.Optional[_aws_cdk_aws_s3_ceddda9d.ObjectLockRetention] = None,
    object_lock_enabled: typing.Optional[builtins.bool] = None,
    object_ownership: typing.Optional[_aws_cdk_aws_s3_ceddda9d.ObjectOwnership] = None,
    public_read_access: typing.Optional[builtins.bool] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    server_access_logs_bucket: typing.Optional[_aws_cdk_aws_s3_ceddda9d.IBucket] = None,
    server_access_logs_prefix: typing.Optional[builtins.str] = None,
    transfer_acceleration: typing.Optional[builtins.bool] = None,
    versioned: typing.Optional[builtins.bool] = None,
    website_error_document: typing.Optional[builtins.str] = None,
    website_index_document: typing.Optional[builtins.str] = None,
    website_redirect: typing.Optional[typing.Union[_aws_cdk_aws_s3_ceddda9d.RedirectTarget, typing.Dict[builtins.str, typing.Any]]] = None,
    website_routing_rules: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_s3_ceddda9d.RoutingRule, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__576a40c037c0f9a1e8953e9d1b17a1026f7d596ac5fc54fc43e0d213874fae25(
    topic: _aws_cdk_aws_sns_ceddda9d.ITopic,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8c722ae4d9bf55cce29be798641c0fc2edce1bd6666919da164ce1643888b11e(
    *,
    repository_name: builtins.str,
    branch: typing.Optional[builtins.str] = None,
    source_action: typing.Optional[_aws_cdk_pipelines_ceddda9d.CodePipelineSource] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cd35d3f7ab025a947f003bfa8401771bc19ba3bee2d5d3483d2a11a867543e9b(
    *,
    max_event_age: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    on_failure: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IDestination] = None,
    on_success: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IDestination] = None,
    retry_attempts: typing.Optional[jsii.Number] = None,
    adot_instrumentation: typing.Optional[typing.Union[_aws_cdk_aws_lambda_ceddda9d.AdotInstrumentationConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    allow_all_outbound: typing.Optional[builtins.bool] = None,
    allow_public_subnet: typing.Optional[builtins.bool] = None,
    architecture: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Architecture] = None,
    code_signing_config: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.ICodeSigningConfig] = None,
    current_version_options: typing.Optional[typing.Union[_aws_cdk_aws_lambda_ceddda9d.VersionOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    dead_letter_queue: typing.Optional[_aws_cdk_aws_sqs_ceddda9d.IQueue] = None,
    dead_letter_queue_enabled: typing.Optional[builtins.bool] = None,
    dead_letter_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
    description: typing.Optional[builtins.str] = None,
    environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    environment_encryption: typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey] = None,
    ephemeral_storage_size: typing.Optional[_aws_cdk_ceddda9d.Size] = None,
    events: typing.Optional[typing.Sequence[_aws_cdk_aws_lambda_ceddda9d.IEventSource]] = None,
    filesystem: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.FileSystem] = None,
    function_name: typing.Optional[builtins.str] = None,
    initial_policy: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    insights_version: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.LambdaInsightsVersion] = None,
    layers: typing.Optional[typing.Sequence[_aws_cdk_aws_lambda_ceddda9d.ILayerVersion]] = None,
    log_retention: typing.Optional[_aws_cdk_aws_logs_ceddda9d.RetentionDays] = None,
    log_retention_retry_options: typing.Optional[typing.Union[_aws_cdk_aws_lambda_ceddda9d.LogRetentionRetryOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    log_retention_role: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole] = None,
    memory_size: typing.Optional[jsii.Number] = None,
    profiling: typing.Optional[builtins.bool] = None,
    profiling_group: typing.Optional[_aws_cdk_aws_codeguruprofiler_ceddda9d.IProfilingGroup] = None,
    reserved_concurrent_executions: typing.Optional[jsii.Number] = None,
    role: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole] = None,
    runtime_management_mode: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.RuntimeManagementMode] = None,
    security_groups: typing.Optional[typing.Sequence[_aws_cdk_aws_ec2_ceddda9d.ISecurityGroup]] = None,
    timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    tracing: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Tracing] = None,
    vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
    vpc_subnets: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
    code: _aws_cdk_aws_lambda_ceddda9d.Code,
    handler: builtins.str,
    runtime: _aws_cdk_aws_lambda_ceddda9d.Runtime,
    errors_alarm_threshold: typing.Optional[jsii.Number] = None,
    errors_comparison_operator: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    errors_evaluation_periods: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e9cf7c3474ce139a45c8e31d476f0b548b9db19082dbea4dffb9287504da5dff(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5e854dfb73af2b1e5b672ba3ec79ee122851867f8bde404e9918340757b3847c(
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5069a8477e1d868a51858f29afe4a12917625d0a7370bc4090fd23bf809c081c(
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
    additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
    state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
    state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    state_machine_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__05acfa3cda54a17101814d614a246f97dc36de4bf27ef87f72f7aa4824dd7b35(
    *,
    additional_install_commands: typing.Optional[typing.Sequence[builtins.str]] = None,
    cdk_version: typing.Optional[builtins.str] = None,
    codeartifact_domain: typing.Optional[builtins.str] = None,
    codeartifact_domain_owner: typing.Optional[builtins.str] = None,
    codeartifact_repository: typing.Optional[builtins.str] = None,
    role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    synth_action: typing.Optional[_aws_cdk_pipelines_ceddda9d.CodeBuildStep] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__50f57d5c758f4bb8a7385b25c9dd1756786a7af562ac0cf743837ff675065839(
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
    additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
    state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
    state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    state_machine_name: typing.Optional[builtins.str] = None,
    destination_flow_config: typing.Optional[typing.Union[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.DestinationFlowConfigProperty, typing.Dict[builtins.str, typing.Any]]] = None,
    flow_execution_status_check_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    flow_name: typing.Optional[builtins.str] = None,
    flow_tasks: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.TaskProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    source_flow_config: typing.Optional[typing.Union[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.SourceFlowConfigProperty, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d02b2a3868910a4789cbcba2028e07a331d2da507e4b4c951dd7801d735bc0ac(
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
    additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
    state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
    state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    state_machine_name: typing.Optional[builtins.str] = None,
    catalog_name: typing.Optional[builtins.str] = None,
    database_name: typing.Optional[builtins.str] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    encryption_option: typing.Optional[_aws_cdk_aws_stepfunctions_tasks_ceddda9d.EncryptionOption] = None,
    output_location: typing.Optional[typing.Union[_aws_cdk_aws_s3_ceddda9d.Location, typing.Dict[builtins.str, typing.Any]]] = None,
    query_string: typing.Optional[builtins.str] = None,
    query_string_path: typing.Optional[builtins.str] = None,
    work_group: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f6be6b9ec4e805f427307a7bc1c743a3f56ffd52c0cc37a1436d75ce69e31b9f(
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
    additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
    state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
    state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    state_machine_name: typing.Optional[builtins.str] = None,
    create_job: typing.Optional[builtins.bool] = None,
    database_outputs: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.DatabaseOutputProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    data_catalog_outputs: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.DataCatalogOutputProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    dataset_name: typing.Optional[builtins.str] = None,
    encryption_key_arn: typing.Optional[builtins.str] = None,
    encryption_mode: typing.Optional[builtins.str] = None,
    job_name: typing.Optional[builtins.str] = None,
    job_role_arn: typing.Optional[builtins.str] = None,
    job_sample: typing.Optional[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.JobSampleProperty, typing.Dict[builtins.str, typing.Any]]] = None,
    job_type: typing.Optional[builtins.str] = None,
    log_subscription: typing.Optional[builtins.str] = None,
    max_capacity: typing.Optional[jsii.Number] = None,
    max_retries: typing.Optional[jsii.Number] = None,
    output_location: typing.Optional[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.OutputLocationProperty, typing.Dict[builtins.str, typing.Any]]] = None,
    outputs: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.OutputProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    profile_configuration: typing.Optional[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.ProfileConfigurationProperty, typing.Dict[builtins.str, typing.Any]]] = None,
    project_name: typing.Optional[builtins.str] = None,
    recipe: typing.Optional[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.RecipeProperty, typing.Dict[builtins.str, typing.Any]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_ceddda9d.CfnTag, typing.Dict[builtins.str, typing.Any]]]] = None,
    timeout: typing.Optional[jsii.Number] = None,
    validation_configurations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.ValidationConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a7ee0133925b96b521f696b544f087847c2e6916f79bbdcf76306ed73653fdb2(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dfe170c2325021dad043fac92cbbedf46c28aacb0956794521a87dbad31593a0(
    id: builtins.str,
    *,
    metric: _aws_cdk_aws_cloudwatch_ceddda9d.IMetric,
    comparison_operator: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    threshold: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1cf78e5b7c077cc8d8a6b8227060c5d2b68df15e3f29e358244b75ef0b897e42(
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__41f4bcf520b1f5e4739a71110428c14cbff5ea45be37a68ea1fe04dbffd91d83(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f2768fcf39322e444b8b05e9cfa0508e071c34b9e8a29e28fc79130506d7aeb6(
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3f9217104050cf03ef7cf7519808ce659edfe6c1ba00722ea6601239921cfd56(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    data_output_prefix: typing.Optional[builtins.str] = None,
    data_stream: typing.Optional[_aws_cdk_aws_kinesis_ceddda9d.Stream] = None,
    data_stream_enabled: typing.Optional[builtins.bool] = None,
    delivery_stream_data_freshness_errors_alarm_threshold: typing.Optional[jsii.Number] = None,
    delivery_stream_data_freshness_errors_evaluation_periods: typing.Optional[jsii.Number] = None,
    firehose_delivery_stream: typing.Optional[_aws_cdk_aws_kinesisfirehose_alpha_30daaf29.DeliveryStream] = None,
    firehose_delivery_stream_props: typing.Optional[typing.Union[DeliveryStreamProps, typing.Dict[builtins.str, typing.Any]]] = None,
    kinesis_firehose_destinations_s3_bucket_props: typing.Optional[typing.Union[_aws_cdk_aws_kinesisfirehose_destinations_alpha_8ee8dbdc.S3BucketProps, typing.Dict[builtins.str, typing.Any]]] = None,
    s3_bucket: typing.Optional[_aws_cdk_aws_s3_ceddda9d.IBucket] = None,
    s3_bucket_props: typing.Optional[typing.Union[_aws_cdk_aws_s3_ceddda9d.BucketProps, typing.Dict[builtins.str, typing.Any]]] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__701f035bba059b01929f2b8055755baf96f72f5089bc32da86d2dc3cacf0f767(
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    data_output_prefix: typing.Optional[builtins.str] = None,
    data_stream: typing.Optional[_aws_cdk_aws_kinesis_ceddda9d.Stream] = None,
    data_stream_enabled: typing.Optional[builtins.bool] = None,
    delivery_stream_data_freshness_errors_alarm_threshold: typing.Optional[jsii.Number] = None,
    delivery_stream_data_freshness_errors_evaluation_periods: typing.Optional[jsii.Number] = None,
    firehose_delivery_stream: typing.Optional[_aws_cdk_aws_kinesisfirehose_alpha_30daaf29.DeliveryStream] = None,
    firehose_delivery_stream_props: typing.Optional[typing.Union[DeliveryStreamProps, typing.Dict[builtins.str, typing.Any]]] = None,
    kinesis_firehose_destinations_s3_bucket_props: typing.Optional[typing.Union[_aws_cdk_aws_kinesisfirehose_destinations_alpha_8ee8dbdc.S3BucketProps, typing.Dict[builtins.str, typing.Any]]] = None,
    s3_bucket: typing.Optional[_aws_cdk_aws_s3_ceddda9d.IBucket] = None,
    s3_bucket_props: typing.Optional[typing.Union[_aws_cdk_aws_s3_ceddda9d.BucketProps, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__36c864b97313236b09b597808a1574a4f4d21024bac872f4e182edbd9a3d0175(
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
    additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
    state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
    state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    state_machine_name: typing.Optional[builtins.str] = None,
    crawler_allow_failure: typing.Optional[builtins.bool] = None,
    crawler_name: typing.Optional[builtins.str] = None,
    crawler_props: typing.Optional[typing.Union[_aws_cdk_aws_glue_ceddda9d.CfnCrawlerProps, typing.Dict[builtins.str, typing.Any]]] = None,
    crawler_role: typing.Optional[builtins.str] = None,
    database_name: typing.Optional[builtins.str] = None,
    job_name: typing.Optional[builtins.str] = None,
    job_props: typing.Optional[typing.Union[_aws_cdk_aws_glue_alpha_ce674d29.JobProps, typing.Dict[builtins.str, typing.Any]]] = None,
    job_run_args: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    state_machine_retry_backoff_rate: typing.Optional[jsii.Number] = None,
    state_machine_retry_interval: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    state_machine_retry_max_attempts: typing.Optional[jsii.Number] = None,
    targets: typing.Optional[typing.Union[_aws_cdk_aws_glue_ceddda9d.CfnCrawler.TargetsProperty, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__defbc9333f2b8b3e2d55373f9b0155e5f6e83609e9153dc24f619d747ca4f133(
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
    additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
    state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
    state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    state_machine_name: typing.Optional[builtins.str] = None,
    redshift_cluster_identifier: builtins.str,
    sql_statements: typing.Sequence[builtins.str],
    database_name: typing.Optional[builtins.str] = None,
    database_user: typing.Optional[builtins.str] = None,
    polling_time: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__faeff4d3ae690cf668837c5bb7641744355445bfe3e6990816e841afad5a577f(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    bucket: typing.Union[_aws_cdk_aws_s3_ceddda9d.IBucket, typing.Sequence[_aws_cdk_aws_s3_ceddda9d.IBucket]],
    event_names: typing.Sequence[builtins.str],
    key_prefix: typing.Optional[typing.Union[builtins.str, typing.Sequence[builtins.str]]] = None,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b66fa30f9df5c5a39526206778107c9f4992a0d357e41d5469d45e647a206a90(
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
    bucket: typing.Union[_aws_cdk_aws_s3_ceddda9d.IBucket, typing.Sequence[_aws_cdk_aws_s3_ceddda9d.IBucket]],
    event_names: typing.Sequence[builtins.str],
    key_prefix: typing.Optional[typing.Union[builtins.str, typing.Sequence[builtins.str]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b5be1a85b67aa2deae08f66dcc56eb002282a0b357ba91df9339c1c9e2cb7401(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    batch_size: typing.Optional[jsii.Number] = None,
    dlq_enabled: typing.Optional[builtins.bool] = None,
    lambda_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IFunction] = None,
    lambda_function_props: typing.Optional[typing.Union[SqsToLambdaStageFunctionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    max_batching_window: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    max_receive_count: typing.Optional[jsii.Number] = None,
    message_group_id: typing.Optional[builtins.str] = None,
    sqs_queue: typing.Optional[_aws_cdk_aws_sqs_ceddda9d.IQueue] = None,
    sqs_queue_props: typing.Optional[typing.Union[_aws_cdk_aws_sqs_ceddda9d.QueueProps, typing.Dict[builtins.str, typing.Any]]] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6ea408fc3fa64f721e1e8e8f5dba2b0b6340914a77963785a7642a5943b0a04a(
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    batch_size: typing.Optional[jsii.Number] = None,
    dlq_enabled: typing.Optional[builtins.bool] = None,
    lambda_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IFunction] = None,
    lambda_function_props: typing.Optional[typing.Union[SqsToLambdaStageFunctionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    max_batching_window: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    max_receive_count: typing.Optional[jsii.Number] = None,
    message_group_id: typing.Optional[builtins.str] = None,
    sqs_queue: typing.Optional[_aws_cdk_aws_sqs_ceddda9d.IQueue] = None,
    sqs_queue_props: typing.Optional[typing.Union[_aws_cdk_aws_sqs_ceddda9d.QueueProps, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c9ccc4da0d6d8eb11cda39b2839889ebd93235f90bbfbdd93a92a3f816c9fd60(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
    state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
    state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    state_machine_name: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__642bc4c0673f5b0f2331c42eaeb1c12c1c4fce53646416b8e239dd0bd724b5d2(
    definition: _aws_cdk_aws_stepfunctions_ceddda9d.IChainable,
    *,
    additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
    state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
    state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    state_machine_name: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__75fdc83ac05ea2b4078c2c89fa4beb028f1353a28c899b42364d275a692f3594(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    destination_flow_config: typing.Optional[typing.Union[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.DestinationFlowConfigProperty, typing.Dict[builtins.str, typing.Any]]] = None,
    flow_execution_status_check_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    flow_name: typing.Optional[builtins.str] = None,
    flow_tasks: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.TaskProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    source_flow_config: typing.Optional[typing.Union[_aws_cdk_aws_appflow_ceddda9d.CfnFlow.SourceFlowConfigProperty, typing.Dict[builtins.str, typing.Any]]] = None,
    additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
    state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
    state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    state_machine_name: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__51d1732123dc8ece0c4c19240b905f56cb50227d150f624d8b798a82b65cbe29(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    catalog_name: typing.Optional[builtins.str] = None,
    database_name: typing.Optional[builtins.str] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    encryption_option: typing.Optional[_aws_cdk_aws_stepfunctions_tasks_ceddda9d.EncryptionOption] = None,
    output_location: typing.Optional[typing.Union[_aws_cdk_aws_s3_ceddda9d.Location, typing.Dict[builtins.str, typing.Any]]] = None,
    query_string: typing.Optional[builtins.str] = None,
    query_string_path: typing.Optional[builtins.str] = None,
    work_group: typing.Optional[builtins.str] = None,
    additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
    state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
    state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    state_machine_name: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a9214d4641d831e11d83d601cf5e13ef25bd3d55977b689c3cefd7aaa9fb0fb5(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    create_job: typing.Optional[builtins.bool] = None,
    database_outputs: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.DatabaseOutputProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    data_catalog_outputs: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.DataCatalogOutputProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    dataset_name: typing.Optional[builtins.str] = None,
    encryption_key_arn: typing.Optional[builtins.str] = None,
    encryption_mode: typing.Optional[builtins.str] = None,
    job_name: typing.Optional[builtins.str] = None,
    job_role_arn: typing.Optional[builtins.str] = None,
    job_sample: typing.Optional[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.JobSampleProperty, typing.Dict[builtins.str, typing.Any]]] = None,
    job_type: typing.Optional[builtins.str] = None,
    log_subscription: typing.Optional[builtins.str] = None,
    max_capacity: typing.Optional[jsii.Number] = None,
    max_retries: typing.Optional[jsii.Number] = None,
    output_location: typing.Optional[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.OutputLocationProperty, typing.Dict[builtins.str, typing.Any]]] = None,
    outputs: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.OutputProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    profile_configuration: typing.Optional[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.ProfileConfigurationProperty, typing.Dict[builtins.str, typing.Any]]] = None,
    project_name: typing.Optional[builtins.str] = None,
    recipe: typing.Optional[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.RecipeProperty, typing.Dict[builtins.str, typing.Any]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_ceddda9d.CfnTag, typing.Dict[builtins.str, typing.Any]]]] = None,
    timeout: typing.Optional[jsii.Number] = None,
    validation_configurations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_databrew_ceddda9d.CfnJob.ValidationConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
    state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
    state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    state_machine_name: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8ddc56c43fee5e5dc6737d945cf18cb6800a5b74340125036ae173083ba761f2(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    crawler_allow_failure: typing.Optional[builtins.bool] = None,
    crawler_name: typing.Optional[builtins.str] = None,
    crawler_props: typing.Optional[typing.Union[_aws_cdk_aws_glue_ceddda9d.CfnCrawlerProps, typing.Dict[builtins.str, typing.Any]]] = None,
    crawler_role: typing.Optional[builtins.str] = None,
    database_name: typing.Optional[builtins.str] = None,
    job_name: typing.Optional[builtins.str] = None,
    job_props: typing.Optional[typing.Union[_aws_cdk_aws_glue_alpha_ce674d29.JobProps, typing.Dict[builtins.str, typing.Any]]] = None,
    job_run_args: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    state_machine_retry_backoff_rate: typing.Optional[jsii.Number] = None,
    state_machine_retry_interval: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    state_machine_retry_max_attempts: typing.Optional[jsii.Number] = None,
    targets: typing.Optional[typing.Union[_aws_cdk_aws_glue_ceddda9d.CfnCrawler.TargetsProperty, typing.Dict[builtins.str, typing.Any]]] = None,
    additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
    state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
    state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    state_machine_name: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2e1a2de894e37c9f2da01cc73a49a2d2fe9ec89a86ba3d42531baaa26002a1a7(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    redshift_cluster_identifier: builtins.str,
    sql_statements: typing.Sequence[builtins.str],
    database_name: typing.Optional[builtins.str] = None,
    database_user: typing.Optional[builtins.str] = None,
    polling_time: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    additional_role_policy_statements: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    state_machine_failed_executions_alarm_evaluation_periods: typing.Optional[jsii.Number] = None,
    state_machine_failed_executions_alarm_threshold: typing.Optional[jsii.Number] = None,
    state_machine_input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    state_machine_name: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f1f6169c1775457f18465db8ac58b6e948ab3cee732db9fb369eb57e96e8b7ef(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    disable_default_topic_policy: typing.Optional[builtins.bool] = None,
    filter_policy: typing.Optional[typing.Mapping[builtins.str, _aws_cdk_aws_sns_ceddda9d.SubscriptionFilter]] = None,
    raw_message_delivery: typing.Optional[builtins.bool] = None,
    sns_dlq_enabled: typing.Optional[builtins.bool] = None,
    sns_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
    sns_topic_props: typing.Optional[typing.Union[_aws_cdk_aws_sns_ceddda9d.TopicProps, typing.Dict[builtins.str, typing.Any]]] = None,
    batch_size: typing.Optional[jsii.Number] = None,
    dlq_enabled: typing.Optional[builtins.bool] = None,
    lambda_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IFunction] = None,
    lambda_function_props: typing.Optional[typing.Union[SqsToLambdaStageFunctionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    max_batching_window: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    max_receive_count: typing.Optional[jsii.Number] = None,
    message_group_id: typing.Optional[builtins.str] = None,
    sqs_queue: typing.Optional[_aws_cdk_aws_sqs_ceddda9d.IQueue] = None,
    sqs_queue_props: typing.Optional[typing.Union[_aws_cdk_aws_sqs_ceddda9d.QueueProps, typing.Dict[builtins.str, typing.Any]]] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b1ced712cbd6acd872556813dd7192431ee7539b2ab066fa0aafd950cc7268b0(
    *,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
    alarms_enabled: typing.Optional[builtins.bool] = None,
    batch_size: typing.Optional[jsii.Number] = None,
    dlq_enabled: typing.Optional[builtins.bool] = None,
    lambda_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IFunction] = None,
    lambda_function_props: typing.Optional[typing.Union[SqsToLambdaStageFunctionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    max_batching_window: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    max_receive_count: typing.Optional[jsii.Number] = None,
    message_group_id: typing.Optional[builtins.str] = None,
    sqs_queue: typing.Optional[_aws_cdk_aws_sqs_ceddda9d.IQueue] = None,
    sqs_queue_props: typing.Optional[typing.Union[_aws_cdk_aws_sqs_ceddda9d.QueueProps, typing.Dict[builtins.str, typing.Any]]] = None,
    disable_default_topic_policy: typing.Optional[builtins.bool] = None,
    filter_policy: typing.Optional[typing.Mapping[builtins.str, _aws_cdk_aws_sns_ceddda9d.SubscriptionFilter]] = None,
    raw_message_delivery: typing.Optional[builtins.bool] = None,
    sns_dlq_enabled: typing.Optional[builtins.bool] = None,
    sns_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
    sns_topic_props: typing.Optional[typing.Union[_aws_cdk_aws_sns_ceddda9d.TopicProps, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass
