r'''
# cdktn

cdktn is a framework for defining cloud infrastructure using Terraform providers and modules. It allows for
users to define infrastructure resources using higher-level programming languages.

## Build

Install dependencies

```bash
yarn install
```

Build the package

```bash
yarn build
```

[Learn More](https://cdk.tf/docs)
'''
from pkgutil import extend_path
__path__ = extend_path(__path__, __name__)

import abc
import builtins
import datetime
import enum
import typing

import jsii
import publication
import typing_extensions

import typeguard
from importlib.metadata import version as _metadata_package_version
TYPEGUARD_MAJOR_VERSION = int(_metadata_package_version('typeguard').split('.')[0])

def check_type(argname: str, value: object, expected_type: typing.Any) -> typing.Any:
    if TYPEGUARD_MAJOR_VERSION <= 2:
        return typeguard.check_type(argname=argname, value=value, expected_type=expected_type) # type:ignore
    else:
        if isinstance(value, jsii._reference_map.InterfaceDynamicProxy): # pyright: ignore [reportAttributeAccessIssue]
           pass
        else:
            if TYPEGUARD_MAJOR_VERSION == 3:
                typeguard.config.collection_check_strategy = typeguard.CollectionCheckStrategy.ALL_ITEMS # type:ignore
                typeguard.check_type(value=value, expected_type=expected_type) # type:ignore
            else:
                typeguard.check_type(value=value, expected_type=expected_type, collection_check_strategy=typeguard.CollectionCheckStrategy.ALL_ITEMS) # type:ignore

from ._jsii import *

import constructs as _constructs_77d1e7e8


@jsii.enum(jsii_type="cdktn.AnnotationMetadataEntryType")
class AnnotationMetadataEntryType(enum.Enum):
    '''
    :stability: experimental
    '''

    INFO = "INFO"
    '''
    :stability: experimental
    '''
    WARN = "WARN"
    '''
    :stability: experimental
    '''
    ERROR = "ERROR"
    '''
    :stability: experimental
    '''


class Annotations(metaclass=jsii.JSIIMeta, jsii_type="cdktn.Annotations"):
    '''(experimental) Includes API for attaching annotations such as warning messages to constructs.

    :stability: experimental
    '''

    @jsii.member(jsii_name="of")
    @builtins.classmethod
    def of(cls, scope: _constructs_77d1e7e8.IConstruct) -> "Annotations":
        '''(experimental) Returns the annotations API for a construct scope.

        :param scope: The scope.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e9289bcf783cd208c819c65416434d4b6ca4219669db4a9b1690754ec81a4ecf)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        return typing.cast("Annotations", jsii.sinvoke(cls, "of", [scope]))

    @jsii.member(jsii_name="addError")
    def add_error(self, message: builtins.str) -> None:
        '''(experimental) Adds an { "error":  } metadata entry to this construct.

        The toolkit will fail synthesis when errors are reported.

        :param message: The error message.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3d142da8716d00d8a62cc9df095cb42b9536075da526106ebbe2d4677dac5e35)
            check_type(argname="argument message", value=message, expected_type=type_hints["message"])
        return typing.cast(None, jsii.invoke(self, "addError", [message]))

    @jsii.member(jsii_name="addInfo")
    def add_info(self, message: builtins.str) -> None:
        '''(experimental) Adds an info metadata entry to this construct.

        The CLI will display the info message when apps are synthesized.

        :param message: The info message.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b19f71ce175c2cb62492f3f6c0e734e720075b37801a4dac34e64f810c1202f4)
            check_type(argname="argument message", value=message, expected_type=type_hints["message"])
        return typing.cast(None, jsii.invoke(self, "addInfo", [message]))

    @jsii.member(jsii_name="addWarning")
    def add_warning(self, message: builtins.str) -> None:
        '''(experimental) Adds a warning metadata entry to this construct.

        The CLI will display the warning when an app is synthesized.
        In a future release the CLI might introduce a --strict flag which
        will then fail the synthesis if it encounters a warning.

        :param message: The warning message.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5374f4afbe43b7f4db43388fec52d4e6519a69cf2196b100757988f42217665d)
            check_type(argname="argument message", value=message, expected_type=type_hints["message"])
        return typing.cast(None, jsii.invoke(self, "addWarning", [message]))


class App(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.App",
):
    '''(experimental) Represents a cdktn application.

    :stability: experimental
    '''

    def __init__(
        self,
        *,
        context: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        hcl_output: typing.Optional[builtins.bool] = None,
        outdir: typing.Optional[builtins.str] = None,
        skip_backend_validation: typing.Optional[builtins.bool] = None,
        skip_validation: typing.Optional[builtins.bool] = None,
        stack_traces: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''(experimental) Defines an app.

        :param context: (experimental) Additional context values for the application. Context set by the CLI or the ``context`` key in ``cdktf.json`` has precedence. Context can be read from any construct using ``node.getContext(key)``. Default: - no additional context
        :param hcl_output: 
        :param outdir: (experimental) The directory to output Terraform resources. If you are using the CDKTN CLI, this value is automatically set from one of the following three sources: - The ``-o`` / ``--output`` CLI option - The ``CDKTF_OUTDIR`` environment variable - The ``outdir`` key in ``cdktf.json`` If you are using the CDKTN CLI and want to set a different value here, you will also need to set the same value via one of the three ways specified above. The most common case to set this value is when you are using the CDKTN library directly (e.g. when writing unit tests). Default: - CDKTF_OUTDIR if defined, otherwise "cdktf.out"
        :param skip_backend_validation: (experimental) Whether to skip backend validation during synthesis of the app. Default: - false
        :param skip_validation: (experimental) Whether to skip all validations during synthesis of the app. Default: - false
        :param stack_traces: 

        :stability: experimental
        '''
        config = AppConfig(
            context=context,
            hcl_output=hcl_output,
            outdir=outdir,
            skip_backend_validation=skip_backend_validation,
            skip_validation=skip_validation,
            stack_traces=stack_traces,
        )

        jsii.create(self.__class__, self, [config])

    @jsii.member(jsii_name="isApp")
    @builtins.classmethod
    def is_app(cls, x: typing.Any) -> builtins.bool:
        '''
        :param x: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__314985dd1b13dc7abf8ef28eee56b891d98970cc4da63171c4a05c0aabdc60d5)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "isApp", [x]))

    @jsii.member(jsii_name="of")
    @builtins.classmethod
    def of(cls, construct: _constructs_77d1e7e8.IConstruct) -> "App":
        '''
        :param construct: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d4161ba5d98212c33f0c6ac4b02b5c4556ed5a8dc06fe4fece1ecf5bdd2f3716)
            check_type(argname="argument construct", value=construct, expected_type=type_hints["construct"])
        return typing.cast("App", jsii.sinvoke(cls, "of", [construct]))

    @jsii.member(jsii_name="crossStackReference")
    def cross_stack_reference(
        self,
        from_stack: "TerraformStack",
        to_stack: "TerraformStack",
        identifier: builtins.str,
    ) -> builtins.str:
        '''(experimental) Creates a reference from one stack to another, invoked on prepareStack since it creates extra resources.

        :param from_stack: -
        :param to_stack: -
        :param identifier: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dd508763dcb927776a0d26940fa560b6888c13155aed629e3bea4a03607a10ae)
            check_type(argname="argument from_stack", value=from_stack, expected_type=type_hints["from_stack"])
            check_type(argname="argument to_stack", value=to_stack, expected_type=type_hints["to_stack"])
            check_type(argname="argument identifier", value=identifier, expected_type=type_hints["identifier"])
        return typing.cast(builtins.str, jsii.invoke(self, "crossStackReference", [from_stack, to_stack, identifier]))

    @jsii.member(jsii_name="synth")
    def synth(self) -> None:
        '''(experimental) Synthesizes all resources to the output directory.

        :stability: experimental
        '''
        return typing.cast(None, jsii.invoke(self, "synth", []))

    @builtins.property
    @jsii.member(jsii_name="hclOutput")
    def hcl_output(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "hclOutput"))

    @builtins.property
    @jsii.member(jsii_name="manifest")
    def manifest(self) -> "Manifest":
        '''
        :stability: experimental
        '''
        return typing.cast("Manifest", jsii.get(self, "manifest"))

    @builtins.property
    @jsii.member(jsii_name="outdir")
    def outdir(self) -> builtins.str:
        '''(experimental) The output directory into which resources will be synthesized.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "outdir"))

    @builtins.property
    @jsii.member(jsii_name="skipBackendValidation")
    def skip_backend_validation(self) -> builtins.bool:
        '''(experimental) Whether to skip backend validation during synthesis of the app.

        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "skipBackendValidation"))

    @builtins.property
    @jsii.member(jsii_name="skipValidation")
    def skip_validation(self) -> builtins.bool:
        '''(experimental) Whether to skip all validations during synthesis of the app.

        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "skipValidation"))

    @builtins.property
    @jsii.member(jsii_name="targetStackId")
    def target_stack_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) The stack which will be synthesized.

        If not set, all stacks will be synthesized.

        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "targetStackId"))


@jsii.data_type(
    jsii_type="cdktn.AppConfig",
    jsii_struct_bases=[],
    name_mapping={
        "context": "context",
        "hcl_output": "hclOutput",
        "outdir": "outdir",
        "skip_backend_validation": "skipBackendValidation",
        "skip_validation": "skipValidation",
        "stack_traces": "stackTraces",
    },
)
class AppConfig:
    def __init__(
        self,
        *,
        context: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        hcl_output: typing.Optional[builtins.bool] = None,
        outdir: typing.Optional[builtins.str] = None,
        skip_backend_validation: typing.Optional[builtins.bool] = None,
        skip_validation: typing.Optional[builtins.bool] = None,
        stack_traces: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param context: (experimental) Additional context values for the application. Context set by the CLI or the ``context`` key in ``cdktf.json`` has precedence. Context can be read from any construct using ``node.getContext(key)``. Default: - no additional context
        :param hcl_output: 
        :param outdir: (experimental) The directory to output Terraform resources. If you are using the CDKTN CLI, this value is automatically set from one of the following three sources: - The ``-o`` / ``--output`` CLI option - The ``CDKTF_OUTDIR`` environment variable - The ``outdir`` key in ``cdktf.json`` If you are using the CDKTN CLI and want to set a different value here, you will also need to set the same value via one of the three ways specified above. The most common case to set this value is when you are using the CDKTN library directly (e.g. when writing unit tests). Default: - CDKTF_OUTDIR if defined, otherwise "cdktf.out"
        :param skip_backend_validation: (experimental) Whether to skip backend validation during synthesis of the app. Default: - false
        :param skip_validation: (experimental) Whether to skip all validations during synthesis of the app. Default: - false
        :param stack_traces: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6bd0a26ff3825fcbda63244de3c5788ef4d457cab4355fd0a712a04a52599d76)
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
            check_type(argname="argument hcl_output", value=hcl_output, expected_type=type_hints["hcl_output"])
            check_type(argname="argument outdir", value=outdir, expected_type=type_hints["outdir"])
            check_type(argname="argument skip_backend_validation", value=skip_backend_validation, expected_type=type_hints["skip_backend_validation"])
            check_type(argname="argument skip_validation", value=skip_validation, expected_type=type_hints["skip_validation"])
            check_type(argname="argument stack_traces", value=stack_traces, expected_type=type_hints["stack_traces"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if context is not None:
            self._values["context"] = context
        if hcl_output is not None:
            self._values["hcl_output"] = hcl_output
        if outdir is not None:
            self._values["outdir"] = outdir
        if skip_backend_validation is not None:
            self._values["skip_backend_validation"] = skip_backend_validation
        if skip_validation is not None:
            self._values["skip_validation"] = skip_validation
        if stack_traces is not None:
            self._values["stack_traces"] = stack_traces

    @builtins.property
    def context(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) Additional context values for the application.

        Context set by the CLI or the ``context`` key in ``cdktf.json`` has precedence.

        Context can be read from any construct using ``node.getContext(key)``.

        :default: - no additional context

        :stability: experimental
        '''
        result = self._values.get("context")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

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

    @builtins.property
    def outdir(self) -> typing.Optional[builtins.str]:
        '''(experimental) The directory to output Terraform resources.

        If you are using the CDKTN CLI, this value is automatically set from one of the following three sources:

        - The ``-o`` / ``--output`` CLI option
        - The ``CDKTF_OUTDIR`` environment variable
        - The ``outdir`` key in ``cdktf.json``

        If you are using the CDKTN CLI and want to set a different value here, you will also need to set the same value via one of the three ways specified above.

        The most common case to set this value is when you are using the CDKTN library directly (e.g. when writing unit tests).

        :default: - CDKTF_OUTDIR if defined, otherwise "cdktf.out"

        :stability: experimental
        '''
        result = self._values.get("outdir")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def skip_backend_validation(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Whether to skip backend validation during synthesis of the app.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("skip_backend_validation")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def skip_validation(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Whether to skip all validations during synthesis of the app.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("skip_validation")
        return typing.cast(typing.Optional[builtins.bool], result)

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


class Aspects(metaclass=jsii.JSIIMeta, jsii_type="cdktn.Aspects"):
    '''(experimental) Aspects can be applied to CDK tree scopes and can operate on the tree before synthesis.

    :stability: experimental
    '''

    @jsii.member(jsii_name="of")
    @builtins.classmethod
    def of(cls, scope: _constructs_77d1e7e8.IConstruct) -> "Aspects":
        '''(experimental) Returns the ``Aspects`` object associated with a construct scope.

        :param scope: The scope for which these aspects will apply.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dfd07ada7b3bf297c914923dcb45a605b0e3d9d6c7481783ac2f43a1d0777357)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        return typing.cast("Aspects", jsii.sinvoke(cls, "of", [scope]))

    @jsii.member(jsii_name="add")
    def add(self, aspect: "IAspect") -> None:
        '''(experimental) Adds an aspect to apply this scope before synthesis.

        :param aspect: The aspect to add.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f4f7745c1c48b778a8610436afdd586398143ae353f53728f976f0b2265477ab)
            check_type(argname="argument aspect", value=aspect, expected_type=type_hints["aspect"])
        return typing.cast(None, jsii.invoke(self, "add", [aspect]))

    @builtins.property
    @jsii.member(jsii_name="all")
    def all(self) -> typing.List["IAspect"]:
        '''(experimental) The list of aspects which were directly applied on this scope.

        :stability: experimental
        '''
        return typing.cast(typing.List["IAspect"], jsii.get(self, "all"))


@jsii.enum(jsii_type="cdktn.AssetType")
class AssetType(enum.Enum):
    '''
    :stability: experimental
    '''

    FILE = "FILE"
    '''
    :stability: experimental
    '''
    DIRECTORY = "DIRECTORY"
    '''
    :stability: experimental
    '''
    ARCHIVE = "ARCHIVE"
    '''
    :stability: experimental
    '''


@jsii.data_type(
    jsii_type="cdktn.AzurermBackendConfig",
    jsii_struct_bases=[],
    name_mapping={
        "container_name": "containerName",
        "key": "key",
        "storage_account_name": "storageAccountName",
        "access_key": "accessKey",
        "client_certificate_password": "clientCertificatePassword",
        "client_certificate_path": "clientCertificatePath",
        "client_id": "clientId",
        "client_secret": "clientSecret",
        "endpoint": "endpoint",
        "environment": "environment",
        "metadata_host": "metadataHost",
        "msi_endpoint": "msiEndpoint",
        "oidc_request_token": "oidcRequestToken",
        "oidc_request_url": "oidcRequestUrl",
        "oidc_token": "oidcToken",
        "oidc_token_file_path": "oidcTokenFilePath",
        "resource_group_name": "resourceGroupName",
        "sas_token": "sasToken",
        "snapshot": "snapshot",
        "subscription_id": "subscriptionId",
        "tenant_id": "tenantId",
        "use_azuread_auth": "useAzureadAuth",
        "use_microsoft_graph": "useMicrosoftGraph",
        "use_msi": "useMsi",
        "use_oidc": "useOidc",
    },
)
class AzurermBackendConfig:
    def __init__(
        self,
        *,
        container_name: builtins.str,
        key: builtins.str,
        storage_account_name: builtins.str,
        access_key: typing.Optional[builtins.str] = None,
        client_certificate_password: typing.Optional[builtins.str] = None,
        client_certificate_path: typing.Optional[builtins.str] = None,
        client_id: typing.Optional[builtins.str] = None,
        client_secret: typing.Optional[builtins.str] = None,
        endpoint: typing.Optional[builtins.str] = None,
        environment: typing.Optional[builtins.str] = None,
        metadata_host: typing.Optional[builtins.str] = None,
        msi_endpoint: typing.Optional[builtins.str] = None,
        oidc_request_token: typing.Optional[builtins.str] = None,
        oidc_request_url: typing.Optional[builtins.str] = None,
        oidc_token: typing.Optional[builtins.str] = None,
        oidc_token_file_path: typing.Optional[builtins.str] = None,
        resource_group_name: typing.Optional[builtins.str] = None,
        sas_token: typing.Optional[builtins.str] = None,
        snapshot: typing.Optional[builtins.bool] = None,
        subscription_id: typing.Optional[builtins.str] = None,
        tenant_id: typing.Optional[builtins.str] = None,
        use_azuread_auth: typing.Optional[builtins.bool] = None,
        use_microsoft_graph: typing.Optional[builtins.bool] = None,
        use_msi: typing.Optional[builtins.bool] = None,
        use_oidc: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''(experimental) Stores the state as a Blob with the given Key within the Blob Container within the Blob Storage Account.

        This backend supports state locking and consistency checking
        with Azure Blob Storage native capabilities.

        Note: By default the Azure Backend uses ADAL for authentication which is deprecated
        in favour of MSAL - MSAL can be used by setting use_microsoft_graph to true.
        The default for this will change in Terraform 1.2,
        so that MSAL authentication is used by default.

        Read more about this backend in the Terraform docs:
        https://developer.hashicorp.com/terraform/language/settings/backends/azurerm

        :param container_name: (experimental) (Required) The Name of the Storage Container within the Storage Account.
        :param key: (experimental) (Required) The name of the Blob used to retrieve/store Terraform's State file inside the Storage Container.
        :param storage_account_name: (experimental) (Required) The Name of the Storage Account.
        :param access_key: (experimental) access_key - (Optional) The Access Key used to access the Blob Storage Account. This can also be sourced from the ARM_ACCESS_KEY environment variable.
        :param client_certificate_password: (experimental) (Optional) The password associated with the Client Certificate specified in client_certificate_path. This can also be sourced from the ARM_CLIENT_CERTIFICATE_PASSWORD environment variable.
        :param client_certificate_path: (experimental) (Optional) The path to the PFX file used as the Client Certificate when authenticating as a Service Principal. This can also be sourced from the ARM_CLIENT_CERTIFICATE_PATH environment variable.
        :param client_id: (experimental) (Optional) The Client ID of the Service Principal. This can also be sourced from the ARM_CLIENT_ID environment variable.
        :param client_secret: (experimental) (Optional) The Client Secret of the Service Principal. This can also be sourced from the ARM_CLIENT_SECRET environment variable.
        :param endpoint: (experimental) (Optional) The Custom Endpoint for Azure Resource Manager. This can also be sourced from the ARM_ENDPOINT environment variable. NOTE: An endpoint should only be configured when using Azure Stack.
        :param environment: (experimental) (Optional) The Azure Environment which should be used. This can also be sourced from the ARM_ENVIRONMENT environment variable. Possible values are public, china, german, stack and usgovernment. Defaults to public.
        :param metadata_host: (experimental) (Optional) The Hostname of the Azure Metadata Service (for example management.azure.com), used to obtain the Cloud Environment when using a Custom Azure Environment. This can also be sourced from the ARM_METADATA_HOSTNAME Environment Variable.).
        :param msi_endpoint: (experimental) (Optional) The path to a custom Managed Service Identity endpoint which is automatically determined if not specified. This can also be sourced from the ARM_MSI_ENDPOINT environment variable.
        :param oidc_request_token: (experimental) (Optional) The bearer token for the request to the OIDC provider. This can also be sourced from the ARM_OIDC_REQUEST_TOKEN or ACTIONS_ID_TOKEN_REQUEST_TOKEN environment variables.
        :param oidc_request_url: (experimental) (Optional) The URL for the OIDC provider from which to request an ID token. This can also be sourced from the ARM_OIDC_REQUEST_URL or ACTIONS_ID_TOKEN_REQUEST_URL environment variables.
        :param oidc_token: (experimental) (Optional) The ID token when authenticating using OpenID Connect (OIDC). This can also be sourced from the ARM_OIDC_TOKEN environment variable.
        :param oidc_token_file_path: (experimental) (Optional) The path to a file containing an ID token when authenticating using OpenID Connect (OIDC). This can also be sourced from the ARM_OIDC_TOKEN_FILE_PATH environment variable.
        :param resource_group_name: (experimental) (Required) The Name of the Resource Group in which the Storage Account exists.
        :param sas_token: (experimental) (Optional) The SAS Token used to access the Blob Storage Account. This can also be sourced from the ARM_SAS_TOKEN environment variable.
        :param snapshot: (experimental) (Optional) Should the Blob used to store the Terraform Statefile be snapshotted before use? Defaults to false. This value can also be sourced from the ARM_SNAPSHOT environment variable.
        :param subscription_id: (experimental) (Optional) The Subscription ID in which the Storage Account exists. This can also be sourced from the ARM_SUBSCRIPTION_ID environment variable.
        :param tenant_id: (experimental) (Optional) The Tenant ID in which the Subscription exists. This can also be sourced from the ARM_TENANT_ID environment variable.
        :param use_azuread_auth: (experimental) (Optional) Should AzureAD Authentication be used to access the Blob Storage Account. This can also be sourced from the ARM_USE_AZUREAD environment variable. Note: When using AzureAD for Authentication to Storage you also need to ensure the Storage Blob Data Owner role is assigned.
        :param use_microsoft_graph: (experimental) (Optional) Should MSAL be used for authentication instead of ADAL, and should Microsoft Graph be used instead of Azure Active Directory Graph? Defaults to true. Note: In Terraform 1.2 the Azure Backend uses MSAL (and Microsoft Graph) rather than ADAL (and Azure Active Directory Graph) for authentication by default - you can disable this by setting use_microsoft_graph to false. This setting will be removed in Terraform 1.3, due to Microsoft's deprecation of ADAL.
        :param use_msi: (experimental) (Optional) Should Managed Service Identity authentication be used? This can also be sourced from the ARM_USE_MSI environment variable.
        :param use_oidc: (experimental) (Optional) Should OIDC authentication be used? This can also be sourced from the ARM_USE_OIDC environment variable. Note: When using OIDC for authentication, use_microsoft_graph must be set to true (which is the default).

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__912173407c419eae209032e0ac104680f082bb5aad4825d0e858e8efc0f9fa76)
            check_type(argname="argument container_name", value=container_name, expected_type=type_hints["container_name"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
            check_type(argname="argument storage_account_name", value=storage_account_name, expected_type=type_hints["storage_account_name"])
            check_type(argname="argument access_key", value=access_key, expected_type=type_hints["access_key"])
            check_type(argname="argument client_certificate_password", value=client_certificate_password, expected_type=type_hints["client_certificate_password"])
            check_type(argname="argument client_certificate_path", value=client_certificate_path, expected_type=type_hints["client_certificate_path"])
            check_type(argname="argument client_id", value=client_id, expected_type=type_hints["client_id"])
            check_type(argname="argument client_secret", value=client_secret, expected_type=type_hints["client_secret"])
            check_type(argname="argument endpoint", value=endpoint, expected_type=type_hints["endpoint"])
            check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
            check_type(argname="argument metadata_host", value=metadata_host, expected_type=type_hints["metadata_host"])
            check_type(argname="argument msi_endpoint", value=msi_endpoint, expected_type=type_hints["msi_endpoint"])
            check_type(argname="argument oidc_request_token", value=oidc_request_token, expected_type=type_hints["oidc_request_token"])
            check_type(argname="argument oidc_request_url", value=oidc_request_url, expected_type=type_hints["oidc_request_url"])
            check_type(argname="argument oidc_token", value=oidc_token, expected_type=type_hints["oidc_token"])
            check_type(argname="argument oidc_token_file_path", value=oidc_token_file_path, expected_type=type_hints["oidc_token_file_path"])
            check_type(argname="argument resource_group_name", value=resource_group_name, expected_type=type_hints["resource_group_name"])
            check_type(argname="argument sas_token", value=sas_token, expected_type=type_hints["sas_token"])
            check_type(argname="argument snapshot", value=snapshot, expected_type=type_hints["snapshot"])
            check_type(argname="argument subscription_id", value=subscription_id, expected_type=type_hints["subscription_id"])
            check_type(argname="argument tenant_id", value=tenant_id, expected_type=type_hints["tenant_id"])
            check_type(argname="argument use_azuread_auth", value=use_azuread_auth, expected_type=type_hints["use_azuread_auth"])
            check_type(argname="argument use_microsoft_graph", value=use_microsoft_graph, expected_type=type_hints["use_microsoft_graph"])
            check_type(argname="argument use_msi", value=use_msi, expected_type=type_hints["use_msi"])
            check_type(argname="argument use_oidc", value=use_oidc, expected_type=type_hints["use_oidc"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "container_name": container_name,
            "key": key,
            "storage_account_name": storage_account_name,
        }
        if access_key is not None:
            self._values["access_key"] = access_key
        if client_certificate_password is not None:
            self._values["client_certificate_password"] = client_certificate_password
        if client_certificate_path is not None:
            self._values["client_certificate_path"] = client_certificate_path
        if client_id is not None:
            self._values["client_id"] = client_id
        if client_secret is not None:
            self._values["client_secret"] = client_secret
        if endpoint is not None:
            self._values["endpoint"] = endpoint
        if environment is not None:
            self._values["environment"] = environment
        if metadata_host is not None:
            self._values["metadata_host"] = metadata_host
        if msi_endpoint is not None:
            self._values["msi_endpoint"] = msi_endpoint
        if oidc_request_token is not None:
            self._values["oidc_request_token"] = oidc_request_token
        if oidc_request_url is not None:
            self._values["oidc_request_url"] = oidc_request_url
        if oidc_token is not None:
            self._values["oidc_token"] = oidc_token
        if oidc_token_file_path is not None:
            self._values["oidc_token_file_path"] = oidc_token_file_path
        if resource_group_name is not None:
            self._values["resource_group_name"] = resource_group_name
        if sas_token is not None:
            self._values["sas_token"] = sas_token
        if snapshot is not None:
            self._values["snapshot"] = snapshot
        if subscription_id is not None:
            self._values["subscription_id"] = subscription_id
        if tenant_id is not None:
            self._values["tenant_id"] = tenant_id
        if use_azuread_auth is not None:
            self._values["use_azuread_auth"] = use_azuread_auth
        if use_microsoft_graph is not None:
            self._values["use_microsoft_graph"] = use_microsoft_graph
        if use_msi is not None:
            self._values["use_msi"] = use_msi
        if use_oidc is not None:
            self._values["use_oidc"] = use_oidc

    @builtins.property
    def container_name(self) -> builtins.str:
        '''(experimental) (Required) The Name of the Storage Container within the Storage Account.

        :stability: experimental
        '''
        result = self._values.get("container_name")
        assert result is not None, "Required property 'container_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def key(self) -> builtins.str:
        '''(experimental) (Required) The name of the Blob used to retrieve/store Terraform's State file inside the Storage Container.

        :stability: experimental
        '''
        result = self._values.get("key")
        assert result is not None, "Required property 'key' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def storage_account_name(self) -> builtins.str:
        '''(experimental) (Required) The Name of the Storage Account.

        :stability: experimental
        '''
        result = self._values.get("storage_account_name")
        assert result is not None, "Required property 'storage_account_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def access_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) access_key - (Optional) The Access Key used to access the Blob Storage Account.

        This can also be sourced from the ARM_ACCESS_KEY environment variable.

        :stability: experimental
        '''
        result = self._values.get("access_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def client_certificate_password(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The password associated with the Client Certificate specified in client_certificate_path.

        This can also be sourced from the
        ARM_CLIENT_CERTIFICATE_PASSWORD environment variable.

        :stability: experimental
        '''
        result = self._values.get("client_certificate_password")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def client_certificate_path(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The path to the PFX file used as the Client Certificate when authenticating as a Service Principal.

        This can also be sourced from the
        ARM_CLIENT_CERTIFICATE_PATH environment variable.

        :stability: experimental
        '''
        result = self._values.get("client_certificate_path")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def client_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The Client ID of the Service Principal.

        This can also be sourced from the ARM_CLIENT_ID environment variable.

        :stability: experimental
        '''
        result = self._values.get("client_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def client_secret(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The Client Secret of the Service Principal.

        This can also be sourced from the ARM_CLIENT_SECRET environment variable.

        :stability: experimental
        '''
        result = self._values.get("client_secret")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The Custom Endpoint for Azure Resource Manager. This can also be sourced from the ARM_ENDPOINT environment variable.

        NOTE: An endpoint should only be configured when using Azure Stack.

        :stability: experimental
        '''
        result = self._values.get("endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def environment(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The Azure Environment which should be used.

        This can also be sourced from the ARM_ENVIRONMENT environment variable.
        Possible values are public, china, german, stack and usgovernment. Defaults to public.

        :stability: experimental
        '''
        result = self._values.get("environment")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def metadata_host(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The Hostname of the Azure Metadata Service (for example management.azure.com), used to obtain the Cloud Environment when using a Custom Azure Environment. This can also be sourced from the ARM_METADATA_HOSTNAME Environment Variable.).

        :stability: experimental
        '''
        result = self._values.get("metadata_host")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def msi_endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The path to a custom Managed Service Identity endpoint which is automatically determined if not specified.

        This can also be sourced from the ARM_MSI_ENDPOINT environment variable.

        :stability: experimental
        '''
        result = self._values.get("msi_endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def oidc_request_token(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The bearer token for the request to the OIDC provider.

        This can
        also be sourced from the ARM_OIDC_REQUEST_TOKEN or
        ACTIONS_ID_TOKEN_REQUEST_TOKEN environment variables.

        :stability: experimental
        '''
        result = self._values.get("oidc_request_token")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def oidc_request_url(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The URL for the OIDC provider from which to request an ID token.

        This can also be sourced from the ARM_OIDC_REQUEST_URL or
        ACTIONS_ID_TOKEN_REQUEST_URL environment variables.

        :stability: experimental
        '''
        result = self._values.get("oidc_request_url")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def oidc_token(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The ID token when authenticating using OpenID Connect (OIDC).

        This can also be sourced from the ARM_OIDC_TOKEN environment variable.

        :stability: experimental
        '''
        result = self._values.get("oidc_token")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def oidc_token_file_path(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The path to a file containing an ID token when authenticating using OpenID Connect (OIDC).

        This can also be sourced from the ARM_OIDC_TOKEN_FILE_PATH environment variable.

        :stability: experimental
        '''
        result = self._values.get("oidc_token_file_path")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def resource_group_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Required) The Name of the Resource Group in which the Storage Account exists.

        :stability: experimental
        '''
        result = self._values.get("resource_group_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sas_token(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The SAS Token used to access the Blob Storage Account.

        This can also be sourced from the ARM_SAS_TOKEN environment variable.

        :stability: experimental
        '''
        result = self._values.get("sas_token")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def snapshot(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Should the Blob used to store the Terraform Statefile be snapshotted before use?

        Defaults to false. This value can also be sourced
        from the ARM_SNAPSHOT environment variable.

        :stability: experimental
        '''
        result = self._values.get("snapshot")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def subscription_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The Subscription ID in which the Storage Account exists.

        This can also be sourced from the ARM_SUBSCRIPTION_ID environment variable.

        :stability: experimental
        '''
        result = self._values.get("subscription_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tenant_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The Tenant ID in which the Subscription exists.

        This can also be sourced from the ARM_TENANT_ID environment variable.

        :stability: experimental
        '''
        result = self._values.get("tenant_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def use_azuread_auth(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Should AzureAD Authentication be used to access the Blob Storage Account.

        This can also be sourced from the ARM_USE_AZUREAD environment
        variable.

        Note: When using AzureAD for Authentication to Storage you also need to
        ensure the Storage Blob Data Owner role is assigned.

        :stability: experimental
        '''
        result = self._values.get("use_azuread_auth")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_microsoft_graph(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Should MSAL be used for authentication instead of ADAL, and should Microsoft Graph be used instead of Azure Active Directory Graph?

        Defaults to true.

        Note: In Terraform 1.2 the Azure Backend uses MSAL (and Microsoft Graph)
        rather than ADAL (and Azure Active Directory Graph) for authentication by
        default - you can disable this by setting use_microsoft_graph to false.
        This setting will be removed in Terraform 1.3, due to Microsoft's
        deprecation of ADAL.

        :stability: experimental
        '''
        result = self._values.get("use_microsoft_graph")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_msi(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Should Managed Service Identity authentication be used?

        This can also be sourced from the ARM_USE_MSI environment variable.

        :stability: experimental
        '''
        result = self._values.get("use_msi")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_oidc(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Should OIDC authentication be used? This can also be sourced from the ARM_USE_OIDC environment variable.

        Note: When using OIDC for authentication, use_microsoft_graph
        must be set to true (which is the default).

        :stability: experimental
        '''
        result = self._values.get("use_oidc")
        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 "AzurermBackendConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.CloudBackendConfig",
    jsii_struct_bases=[],
    name_mapping={
        "organization": "organization",
        "workspaces": "workspaces",
        "hostname": "hostname",
        "token": "token",
    },
)
class CloudBackendConfig:
    def __init__(
        self,
        *,
        organization: builtins.str,
        workspaces: typing.Union["NamedCloudWorkspace", "TaggedCloudWorkspaces"],
        hostname: typing.Optional[builtins.str] = None,
        token: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) The Cloud Backend synthesizes a {@link https://developer.hashicorp.com/terraform/cli/cloud/settings#the-cloud-block cloud block}. The cloud block is a nested block within the top-level terraform settings block. It specifies which Terraform Cloud workspaces to use for the current working directory. The cloud block only affects Terraform CLI's behavior. When Terraform Cloud uses a configuration that contains a cloud block - for example, when a workspace is configured to use a VCS provider directly - it ignores the block and behaves according to its own workspace settings.

        https://developer.hashicorp.com/terraform/cli/cloud/settings#arguments

        :param organization: (experimental) The name of the organization containing the workspace(s) the current configuration should use.
        :param workspaces: (experimental) A nested block that specifies which remote Terraform Cloud workspaces to use for the current configuration. The workspaces block must contain exactly one of the following arguments, each denoting a strategy for how workspaces should be mapped:
        :param hostname: (experimental) The hostname of a Terraform Enterprise installation, if using Terraform Enterprise. Default: app.terraform.io
        :param token: (experimental) The token used to authenticate with Terraform Cloud. We recommend omitting the token from the configuration, and instead using terraform login or manually configuring credentials in the CLI config file.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4c43a277c741c97005cffe2a27390aad01d95fded1b13c16a35f07ccaec84f7a)
            check_type(argname="argument organization", value=organization, expected_type=type_hints["organization"])
            check_type(argname="argument workspaces", value=workspaces, expected_type=type_hints["workspaces"])
            check_type(argname="argument hostname", value=hostname, expected_type=type_hints["hostname"])
            check_type(argname="argument token", value=token, expected_type=type_hints["token"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "organization": organization,
            "workspaces": workspaces,
        }
        if hostname is not None:
            self._values["hostname"] = hostname
        if token is not None:
            self._values["token"] = token

    @builtins.property
    def organization(self) -> builtins.str:
        '''(experimental) The name of the organization containing the workspace(s) the current configuration should use.

        :stability: experimental
        '''
        result = self._values.get("organization")
        assert result is not None, "Required property 'organization' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def workspaces(
        self,
    ) -> typing.Union["NamedCloudWorkspace", "TaggedCloudWorkspaces"]:
        '''(experimental) A nested block that specifies which remote Terraform Cloud workspaces to use for the current configuration.

        The workspaces block must contain exactly one of the following arguments, each denoting a strategy for how workspaces should be mapped:

        :stability: experimental
        '''
        result = self._values.get("workspaces")
        assert result is not None, "Required property 'workspaces' is missing"
        return typing.cast(typing.Union["NamedCloudWorkspace", "TaggedCloudWorkspaces"], result)

    @builtins.property
    def hostname(self) -> typing.Optional[builtins.str]:
        '''(experimental) The hostname of a Terraform Enterprise installation, if using Terraform Enterprise.

        :default: app.terraform.io

        :stability: experimental
        '''
        result = self._values.get("hostname")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def token(self) -> typing.Optional[builtins.str]:
        '''(experimental) The token used to authenticate with Terraform Cloud.

        We recommend omitting the token from the configuration, and instead using terraform login or manually configuring credentials in the CLI config file.

        :stability: experimental
        '''
        result = self._values.get("token")
        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 "CloudBackendConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class CloudWorkspace(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="cdktn.CloudWorkspace",
):
    '''(experimental) A cloud workspace can either be a single named workspace, or a list of tagged workspaces.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="toTerraform")
    @abc.abstractmethod
    def to_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        ...


class _CloudWorkspaceProxy(CloudWorkspace):
    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toTerraform", []))

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


@jsii.data_type(
    jsii_type="cdktn.ConsulBackendConfig",
    jsii_struct_bases=[],
    name_mapping={
        "access_token": "accessToken",
        "path": "path",
        "address": "address",
        "ca_file": "caFile",
        "cert_file": "certFile",
        "datacenter": "datacenter",
        "gzip": "gzip",
        "http_auth": "httpAuth",
        "key_file": "keyFile",
        "lock": "lock",
        "scheme": "scheme",
    },
)
class ConsulBackendConfig:
    def __init__(
        self,
        *,
        access_token: builtins.str,
        path: builtins.str,
        address: typing.Optional[builtins.str] = None,
        ca_file: typing.Optional[builtins.str] = None,
        cert_file: typing.Optional[builtins.str] = None,
        datacenter: typing.Optional[builtins.str] = None,
        gzip: typing.Optional[builtins.bool] = None,
        http_auth: typing.Optional[builtins.str] = None,
        key_file: typing.Optional[builtins.str] = None,
        lock: typing.Optional[builtins.bool] = None,
        scheme: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Stores the state in the Consul KV store at a given path. This backend supports state locking.

        Read more about this backend in the Terraform docs:
        https://developer.hashicorp.com/terraform/language/settings/backends/consul

        :param access_token: (experimental) (Required) Access token.
        :param path: (experimental) (Required) Path in the Consul KV store.
        :param address: (experimental) (Optional) DNS name and port of your Consul endpoint specified in the format dnsname:port. Defaults to the local agent HTTP listener.
        :param ca_file: (experimental) (Optional) A path to a PEM-encoded certificate authority used to verify the remote agent's certificate.
        :param cert_file: (experimental) (Optional) A path to a PEM-encoded certificate provided to the remote agent; requires use of key_file.
        :param datacenter: (experimental) (Optional) The datacenter to use. Defaults to that of the agent.
        :param gzip: (experimental) (Optional) true to compress the state data using gzip, or false (the default) to leave it uncompressed.
        :param http_auth: (experimental) (Optional) HTTP Basic Authentication credentials to be used when communicating with Consul, in the format of either user or user:pass.
        :param key_file: (experimental) (Optional) A path to a PEM-encoded private key, required if cert_file is specified.
        :param lock: (experimental) (Optional) false to disable locking. This defaults to true, but will require session permissions with Consul and at least kv write permissions on $path/.lock to perform locking.
        :param scheme: (experimental) (Optional) Specifies what protocol to use when talking to the given address,either http or https. SSL support can also be triggered by setting then environment variable CONSUL_HTTP_SSL to true.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__baa70c8729c8356212ac489f983efd7c561527ee11bad26a38dd5c66bc2c0362)
            check_type(argname="argument access_token", value=access_token, expected_type=type_hints["access_token"])
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
            check_type(argname="argument address", value=address, expected_type=type_hints["address"])
            check_type(argname="argument ca_file", value=ca_file, expected_type=type_hints["ca_file"])
            check_type(argname="argument cert_file", value=cert_file, expected_type=type_hints["cert_file"])
            check_type(argname="argument datacenter", value=datacenter, expected_type=type_hints["datacenter"])
            check_type(argname="argument gzip", value=gzip, expected_type=type_hints["gzip"])
            check_type(argname="argument http_auth", value=http_auth, expected_type=type_hints["http_auth"])
            check_type(argname="argument key_file", value=key_file, expected_type=type_hints["key_file"])
            check_type(argname="argument lock", value=lock, expected_type=type_hints["lock"])
            check_type(argname="argument scheme", value=scheme, expected_type=type_hints["scheme"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "access_token": access_token,
            "path": path,
        }
        if address is not None:
            self._values["address"] = address
        if ca_file is not None:
            self._values["ca_file"] = ca_file
        if cert_file is not None:
            self._values["cert_file"] = cert_file
        if datacenter is not None:
            self._values["datacenter"] = datacenter
        if gzip is not None:
            self._values["gzip"] = gzip
        if http_auth is not None:
            self._values["http_auth"] = http_auth
        if key_file is not None:
            self._values["key_file"] = key_file
        if lock is not None:
            self._values["lock"] = lock
        if scheme is not None:
            self._values["scheme"] = scheme

    @builtins.property
    def access_token(self) -> builtins.str:
        '''(experimental) (Required) Access token.

        :stability: experimental
        '''
        result = self._values.get("access_token")
        assert result is not None, "Required property 'access_token' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def path(self) -> builtins.str:
        '''(experimental) (Required) Path in the Consul KV store.

        :stability: experimental
        '''
        result = self._values.get("path")
        assert result is not None, "Required property 'path' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def address(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) DNS name and port of your Consul endpoint specified in the format dnsname:port.

        Defaults to the local agent HTTP listener.

        :stability: experimental
        '''
        result = self._values.get("address")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ca_file(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A path to a PEM-encoded certificate authority used to verify the remote agent's certificate.

        :stability: experimental
        '''
        result = self._values.get("ca_file")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def cert_file(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A path to a PEM-encoded certificate provided to the remote agent;

        requires use of key_file.

        :stability: experimental
        '''
        result = self._values.get("cert_file")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def datacenter(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The datacenter to use.

        Defaults to that of the agent.

        :stability: experimental
        '''
        result = self._values.get("datacenter")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def gzip(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) true to compress the state data using gzip, or false (the default) to leave it uncompressed.

        :stability: experimental
        '''
        result = self._values.get("gzip")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def http_auth(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) HTTP Basic Authentication credentials to be used when communicating with Consul, in the format of either user or user:pass.

        :stability: experimental
        '''
        result = self._values.get("http_auth")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def key_file(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A path to a PEM-encoded private key, required if cert_file is specified.

        :stability: experimental
        '''
        result = self._values.get("key_file")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def lock(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) false to disable locking.

        This defaults to true, but will require session permissions with Consul and
        at least kv write permissions on $path/.lock to perform locking.

        :stability: experimental
        '''
        result = self._values.get("lock")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def scheme(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Specifies what protocol to use when talking to the given address,either http or https.

        SSL support can also be triggered by setting then environment variable CONSUL_HTTP_SSL to true.

        :stability: experimental
        '''
        result = self._values.get("scheme")
        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 "ConsulBackendConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.CosBackendAssumeRole",
    jsii_struct_bases=[],
    name_mapping={
        "role_arn": "roleArn",
        "session_duration": "sessionDuration",
        "session_name": "sessionName",
        "policy": "policy",
    },
)
class CosBackendAssumeRole:
    def __init__(
        self,
        *,
        role_arn: builtins.str,
        session_duration: jsii.Number,
        session_name: builtins.str,
        policy: typing.Any = None,
    ) -> None:
        '''
        :param role_arn: (experimental) (Required) The ARN of the role to assume. It can be sourced from the TENCENTCLOUD_ASSUME_ROLE_ARN.
        :param session_duration: (experimental) (Required) The duration of the session when making the AssumeRole call. Its value ranges from 0 to 43200(seconds), and default is 7200 seconds. It can be sourced from the TENCENTCLOUD_ASSUME_ROLE_SESSION_DURATION.
        :param session_name: (experimental) (Required) The session name to use when making the AssumeRole call. It can be sourced from the TENCENTCLOUD_ASSUME_ROLE_SESSION_NAME.
        :param policy: (experimental) (Optional) A more restrictive policy when making the AssumeRole call. Its content must not contains principal elements. Please refer to {@link https://www.tencentcloud.com/document/product/598/10603 policies syntax logic}.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__81c9621f790496ec286371d0b5f290fcdeda375a3069aef5e6afc305d6a2b73f)
            check_type(argname="argument role_arn", value=role_arn, expected_type=type_hints["role_arn"])
            check_type(argname="argument session_duration", value=session_duration, expected_type=type_hints["session_duration"])
            check_type(argname="argument session_name", value=session_name, expected_type=type_hints["session_name"])
            check_type(argname="argument policy", value=policy, expected_type=type_hints["policy"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "role_arn": role_arn,
            "session_duration": session_duration,
            "session_name": session_name,
        }
        if policy is not None:
            self._values["policy"] = policy

    @builtins.property
    def role_arn(self) -> builtins.str:
        '''(experimental) (Required) The ARN of the role to assume.

        It can be sourced from the TENCENTCLOUD_ASSUME_ROLE_ARN.

        :stability: experimental
        '''
        result = self._values.get("role_arn")
        assert result is not None, "Required property 'role_arn' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def session_duration(self) -> jsii.Number:
        '''(experimental) (Required) The duration of the session when making the AssumeRole call.

        Its value ranges from 0 to 43200(seconds), and default is 7200 seconds.
        It can be sourced from the TENCENTCLOUD_ASSUME_ROLE_SESSION_DURATION.

        :stability: experimental
        '''
        result = self._values.get("session_duration")
        assert result is not None, "Required property 'session_duration' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def session_name(self) -> builtins.str:
        '''(experimental) (Required) The session name to use when making the AssumeRole call.

        It can be sourced from the TENCENTCLOUD_ASSUME_ROLE_SESSION_NAME.

        :stability: experimental
        '''
        result = self._values.get("session_name")
        assert result is not None, "Required property 'session_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def policy(self) -> typing.Any:
        '''(experimental) (Optional) A more restrictive policy when making the AssumeRole call.

        Its content must not contains principal elements.
        Please refer to {@link https://www.tencentcloud.com/document/product/598/10603 policies syntax logic}.

        :stability: experimental
        '''
        result = self._values.get("policy")
        return typing.cast(typing.Any, 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 "CosBackendAssumeRole(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.CosBackendConfig",
    jsii_struct_bases=[],
    name_mapping={
        "bucket": "bucket",
        "accelerate": "accelerate",
        "acl": "acl",
        "assume_role": "assumeRole",
        "domain": "domain",
        "encrypt": "encrypt",
        "endpoint": "endpoint",
        "key": "key",
        "prefix": "prefix",
        "region": "region",
        "secret_id": "secretId",
        "secret_key": "secretKey",
        "security_token": "securityToken",
    },
)
class CosBackendConfig:
    def __init__(
        self,
        *,
        bucket: builtins.str,
        accelerate: typing.Optional[builtins.bool] = None,
        acl: typing.Optional[builtins.str] = None,
        assume_role: typing.Optional[typing.Union[CosBackendAssumeRole, typing.Dict[builtins.str, typing.Any]]] = None,
        domain: typing.Optional[builtins.str] = None,
        encrypt: typing.Optional[builtins.bool] = None,
        endpoint: typing.Optional[builtins.str] = None,
        key: typing.Optional[builtins.str] = None,
        prefix: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        secret_id: typing.Optional[builtins.str] = None,
        secret_key: typing.Optional[builtins.str] = None,
        security_token: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Stores the state as an object in a configurable prefix in a given bucket on Tencent Cloud Object Storage (COS).

        This backend supports state locking.

        Warning! It is highly recommended that you enable Object Versioning on the COS bucket to allow for state recovery in the case of accidental deletions and human error.

        Read more about this backend in the Terraform docs:
        https://developer.hashicorp.com/terraform/language/settings/backends/cos

        :param bucket: (experimental) (Required) The name of the COS bucket. You shall manually create it first.
        :param accelerate: (experimental) (Optional) Whether to enable global Acceleration. Defaults to false.
        :param acl: (experimental) (Optional) Object ACL to be applied to the state file, allows private and public-read. Defaults to private.
        :param assume_role: (experimental) (Optional) The assume_role block. If provided, terraform will attempt to assume this role using the supplied credentials.
        :param domain: (experimental) (Optional) The root domain of the API request. Defaults to tencentcloudapi.com. It supports the environment variable TENCENTCLOUD_DOMAIN.
        :param encrypt: (experimental) (Optional) Whether to enable server side encryption of the state file. If it is true, COS will use 'AES256' encryption algorithm to encrypt state file.
        :param endpoint: (experimental) (Optional) The Custom Endpoint for the COS backend. It supports the environment variable TENCENTCLOUD_ENDPOINT.
        :param key: (experimental) (Optional) The path for saving the state file in bucket. Defaults to terraform.tfstate.
        :param prefix: (experimental) (Optional) The directory for saving the state file in bucket. Default to "env:".
        :param region: (experimental) (Optional) The region of the COS bucket. It supports environment variables TENCENTCLOUD_REGION.
        :param secret_id: (experimental) (Optional) Secret id of Tencent Cloud. It supports environment variables TENCENTCLOUD_SECRET_ID.
        :param secret_key: (experimental) (Optional) Secret key of Tencent Cloud. It supports environment variables TENCENTCLOUD_SECRET_KEY.
        :param security_token: (experimental) (Optional) TencentCloud Security Token of temporary access credentials. It supports environment variables TENCENTCLOUD_SECURITY_TOKEN.

        :stability: experimental
        '''
        if isinstance(assume_role, dict):
            assume_role = CosBackendAssumeRole(**assume_role)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__67a315d21c300ce89cca4c20447408680c7216a2221cf4a7f33b35c6f0294cbe)
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument accelerate", value=accelerate, expected_type=type_hints["accelerate"])
            check_type(argname="argument acl", value=acl, expected_type=type_hints["acl"])
            check_type(argname="argument assume_role", value=assume_role, expected_type=type_hints["assume_role"])
            check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
            check_type(argname="argument encrypt", value=encrypt, expected_type=type_hints["encrypt"])
            check_type(argname="argument endpoint", value=endpoint, expected_type=type_hints["endpoint"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument secret_id", value=secret_id, expected_type=type_hints["secret_id"])
            check_type(argname="argument secret_key", value=secret_key, expected_type=type_hints["secret_key"])
            check_type(argname="argument security_token", value=security_token, expected_type=type_hints["security_token"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bucket": bucket,
        }
        if accelerate is not None:
            self._values["accelerate"] = accelerate
        if acl is not None:
            self._values["acl"] = acl
        if assume_role is not None:
            self._values["assume_role"] = assume_role
        if domain is not None:
            self._values["domain"] = domain
        if encrypt is not None:
            self._values["encrypt"] = encrypt
        if endpoint is not None:
            self._values["endpoint"] = endpoint
        if key is not None:
            self._values["key"] = key
        if prefix is not None:
            self._values["prefix"] = prefix
        if region is not None:
            self._values["region"] = region
        if secret_id is not None:
            self._values["secret_id"] = secret_id
        if secret_key is not None:
            self._values["secret_key"] = secret_key
        if security_token is not None:
            self._values["security_token"] = security_token

    @builtins.property
    def bucket(self) -> builtins.str:
        '''(experimental) (Required) The name of the COS bucket.

        You shall manually create it first.

        :stability: experimental
        '''
        result = self._values.get("bucket")
        assert result is not None, "Required property 'bucket' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def accelerate(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Whether to enable global Acceleration.

        Defaults to false.

        :stability: experimental
        '''
        result = self._values.get("accelerate")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def acl(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Object ACL to be applied to the state file, allows private and public-read.

        Defaults to private.

        :stability: experimental
        '''
        result = self._values.get("acl")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def assume_role(self) -> typing.Optional[CosBackendAssumeRole]:
        '''(experimental) (Optional) The assume_role block.

        If provided, terraform will attempt to assume this role using the supplied credentials.

        :stability: experimental
        '''
        result = self._values.get("assume_role")
        return typing.cast(typing.Optional[CosBackendAssumeRole], result)

    @builtins.property
    def domain(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The root domain of the API request.

        Defaults to tencentcloudapi.com.
        It supports the environment variable TENCENTCLOUD_DOMAIN.

        :stability: experimental
        '''
        result = self._values.get("domain")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def encrypt(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Whether to enable server side encryption of the state file.

        If it is true, COS will use 'AES256' encryption algorithm to encrypt state file.

        :stability: experimental
        '''
        result = self._values.get("encrypt")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The Custom Endpoint for the COS backend.

        It supports the environment variable TENCENTCLOUD_ENDPOINT.

        :stability: experimental
        '''
        result = self._values.get("endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The path for saving the state file in bucket.

        Defaults to terraform.tfstate.

        :stability: experimental
        '''
        result = self._values.get("key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def prefix(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The directory for saving the state file in bucket.

        Default to "env:".

        :stability: experimental
        '''
        result = self._values.get("prefix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The region of the COS bucket.

        It supports environment variables TENCENTCLOUD_REGION.

        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def secret_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Secret id of Tencent Cloud.

        It supports environment variables TENCENTCLOUD_SECRET_ID.

        :stability: experimental
        '''
        result = self._values.get("secret_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def secret_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Secret key of Tencent Cloud.

        It supports environment variables TENCENTCLOUD_SECRET_KEY.

        :stability: experimental
        '''
        result = self._values.get("secret_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def security_token(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) TencentCloud Security Token of temporary access credentials.

        It supports environment variables TENCENTCLOUD_SECURITY_TOKEN.

        :stability: experimental
        '''
        result = self._values.get("security_token")
        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 "CosBackendConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.DataTerraformRemoteStateConfig",
    jsii_struct_bases=[],
    name_mapping={"defaults": "defaults", "workspace": "workspace"},
)
class DataTerraformRemoteStateConfig:
    def __init__(
        self,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param defaults: 
        :param workspace: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__af2f5933ed8e8293b381c53ae0a863407c84bebdb688791a908756930c5cd04f)
            check_type(argname="argument defaults", value=defaults, expected_type=type_hints["defaults"])
            check_type(argname="argument workspace", value=workspace, expected_type=type_hints["workspace"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if defaults is not None:
            self._values["defaults"] = defaults
        if workspace is not None:
            self._values["workspace"] = workspace

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

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


@jsii.data_type(
    jsii_type="cdktn.DataTerraformRemoteStateConsulConfig",
    jsii_struct_bases=[DataTerraformRemoteStateConfig, ConsulBackendConfig],
    name_mapping={
        "defaults": "defaults",
        "workspace": "workspace",
        "access_token": "accessToken",
        "path": "path",
        "address": "address",
        "ca_file": "caFile",
        "cert_file": "certFile",
        "datacenter": "datacenter",
        "gzip": "gzip",
        "http_auth": "httpAuth",
        "key_file": "keyFile",
        "lock": "lock",
        "scheme": "scheme",
    },
)
class DataTerraformRemoteStateConsulConfig(
    DataTerraformRemoteStateConfig,
    ConsulBackendConfig,
):
    def __init__(
        self,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        access_token: builtins.str,
        path: builtins.str,
        address: typing.Optional[builtins.str] = None,
        ca_file: typing.Optional[builtins.str] = None,
        cert_file: typing.Optional[builtins.str] = None,
        datacenter: typing.Optional[builtins.str] = None,
        gzip: typing.Optional[builtins.bool] = None,
        http_auth: typing.Optional[builtins.str] = None,
        key_file: typing.Optional[builtins.str] = None,
        lock: typing.Optional[builtins.bool] = None,
        scheme: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param defaults: 
        :param workspace: 
        :param access_token: (experimental) (Required) Access token.
        :param path: (experimental) (Required) Path in the Consul KV store.
        :param address: (experimental) (Optional) DNS name and port of your Consul endpoint specified in the format dnsname:port. Defaults to the local agent HTTP listener.
        :param ca_file: (experimental) (Optional) A path to a PEM-encoded certificate authority used to verify the remote agent's certificate.
        :param cert_file: (experimental) (Optional) A path to a PEM-encoded certificate provided to the remote agent; requires use of key_file.
        :param datacenter: (experimental) (Optional) The datacenter to use. Defaults to that of the agent.
        :param gzip: (experimental) (Optional) true to compress the state data using gzip, or false (the default) to leave it uncompressed.
        :param http_auth: (experimental) (Optional) HTTP Basic Authentication credentials to be used when communicating with Consul, in the format of either user or user:pass.
        :param key_file: (experimental) (Optional) A path to a PEM-encoded private key, required if cert_file is specified.
        :param lock: (experimental) (Optional) false to disable locking. This defaults to true, but will require session permissions with Consul and at least kv write permissions on $path/.lock to perform locking.
        :param scheme: (experimental) (Optional) Specifies what protocol to use when talking to the given address,either http or https. SSL support can also be triggered by setting then environment variable CONSUL_HTTP_SSL to true.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eabe5784d64b19bb922d018b00dca4e55c987cb9a5dbc553636e0fb9b9b88d02)
            check_type(argname="argument defaults", value=defaults, expected_type=type_hints["defaults"])
            check_type(argname="argument workspace", value=workspace, expected_type=type_hints["workspace"])
            check_type(argname="argument access_token", value=access_token, expected_type=type_hints["access_token"])
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
            check_type(argname="argument address", value=address, expected_type=type_hints["address"])
            check_type(argname="argument ca_file", value=ca_file, expected_type=type_hints["ca_file"])
            check_type(argname="argument cert_file", value=cert_file, expected_type=type_hints["cert_file"])
            check_type(argname="argument datacenter", value=datacenter, expected_type=type_hints["datacenter"])
            check_type(argname="argument gzip", value=gzip, expected_type=type_hints["gzip"])
            check_type(argname="argument http_auth", value=http_auth, expected_type=type_hints["http_auth"])
            check_type(argname="argument key_file", value=key_file, expected_type=type_hints["key_file"])
            check_type(argname="argument lock", value=lock, expected_type=type_hints["lock"])
            check_type(argname="argument scheme", value=scheme, expected_type=type_hints["scheme"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "access_token": access_token,
            "path": path,
        }
        if defaults is not None:
            self._values["defaults"] = defaults
        if workspace is not None:
            self._values["workspace"] = workspace
        if address is not None:
            self._values["address"] = address
        if ca_file is not None:
            self._values["ca_file"] = ca_file
        if cert_file is not None:
            self._values["cert_file"] = cert_file
        if datacenter is not None:
            self._values["datacenter"] = datacenter
        if gzip is not None:
            self._values["gzip"] = gzip
        if http_auth is not None:
            self._values["http_auth"] = http_auth
        if key_file is not None:
            self._values["key_file"] = key_file
        if lock is not None:
            self._values["lock"] = lock
        if scheme is not None:
            self._values["scheme"] = scheme

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

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

    @builtins.property
    def access_token(self) -> builtins.str:
        '''(experimental) (Required) Access token.

        :stability: experimental
        '''
        result = self._values.get("access_token")
        assert result is not None, "Required property 'access_token' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def path(self) -> builtins.str:
        '''(experimental) (Required) Path in the Consul KV store.

        :stability: experimental
        '''
        result = self._values.get("path")
        assert result is not None, "Required property 'path' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def address(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) DNS name and port of your Consul endpoint specified in the format dnsname:port.

        Defaults to the local agent HTTP listener.

        :stability: experimental
        '''
        result = self._values.get("address")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ca_file(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A path to a PEM-encoded certificate authority used to verify the remote agent's certificate.

        :stability: experimental
        '''
        result = self._values.get("ca_file")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def cert_file(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A path to a PEM-encoded certificate provided to the remote agent;

        requires use of key_file.

        :stability: experimental
        '''
        result = self._values.get("cert_file")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def datacenter(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The datacenter to use.

        Defaults to that of the agent.

        :stability: experimental
        '''
        result = self._values.get("datacenter")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def gzip(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) true to compress the state data using gzip, or false (the default) to leave it uncompressed.

        :stability: experimental
        '''
        result = self._values.get("gzip")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def http_auth(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) HTTP Basic Authentication credentials to be used when communicating with Consul, in the format of either user or user:pass.

        :stability: experimental
        '''
        result = self._values.get("http_auth")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def key_file(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A path to a PEM-encoded private key, required if cert_file is specified.

        :stability: experimental
        '''
        result = self._values.get("key_file")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def lock(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) false to disable locking.

        This defaults to true, but will require session permissions with Consul and
        at least kv write permissions on $path/.lock to perform locking.

        :stability: experimental
        '''
        result = self._values.get("lock")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def scheme(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Specifies what protocol to use when talking to the given address,either http or https.

        SSL support can also be triggered by setting then environment variable CONSUL_HTTP_SSL to true.

        :stability: experimental
        '''
        result = self._values.get("scheme")
        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 "DataTerraformRemoteStateConsulConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.DataTerraformRemoteStateCosConfig",
    jsii_struct_bases=[DataTerraformRemoteStateConfig, CosBackendConfig],
    name_mapping={
        "defaults": "defaults",
        "workspace": "workspace",
        "bucket": "bucket",
        "accelerate": "accelerate",
        "acl": "acl",
        "assume_role": "assumeRole",
        "domain": "domain",
        "encrypt": "encrypt",
        "endpoint": "endpoint",
        "key": "key",
        "prefix": "prefix",
        "region": "region",
        "secret_id": "secretId",
        "secret_key": "secretKey",
        "security_token": "securityToken",
    },
)
class DataTerraformRemoteStateCosConfig(
    DataTerraformRemoteStateConfig,
    CosBackendConfig,
):
    def __init__(
        self,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        bucket: builtins.str,
        accelerate: typing.Optional[builtins.bool] = None,
        acl: typing.Optional[builtins.str] = None,
        assume_role: typing.Optional[typing.Union[CosBackendAssumeRole, typing.Dict[builtins.str, typing.Any]]] = None,
        domain: typing.Optional[builtins.str] = None,
        encrypt: typing.Optional[builtins.bool] = None,
        endpoint: typing.Optional[builtins.str] = None,
        key: typing.Optional[builtins.str] = None,
        prefix: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        secret_id: typing.Optional[builtins.str] = None,
        secret_key: typing.Optional[builtins.str] = None,
        security_token: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param defaults: 
        :param workspace: 
        :param bucket: (experimental) (Required) The name of the COS bucket. You shall manually create it first.
        :param accelerate: (experimental) (Optional) Whether to enable global Acceleration. Defaults to false.
        :param acl: (experimental) (Optional) Object ACL to be applied to the state file, allows private and public-read. Defaults to private.
        :param assume_role: (experimental) (Optional) The assume_role block. If provided, terraform will attempt to assume this role using the supplied credentials.
        :param domain: (experimental) (Optional) The root domain of the API request. Defaults to tencentcloudapi.com. It supports the environment variable TENCENTCLOUD_DOMAIN.
        :param encrypt: (experimental) (Optional) Whether to enable server side encryption of the state file. If it is true, COS will use 'AES256' encryption algorithm to encrypt state file.
        :param endpoint: (experimental) (Optional) The Custom Endpoint for the COS backend. It supports the environment variable TENCENTCLOUD_ENDPOINT.
        :param key: (experimental) (Optional) The path for saving the state file in bucket. Defaults to terraform.tfstate.
        :param prefix: (experimental) (Optional) The directory for saving the state file in bucket. Default to "env:".
        :param region: (experimental) (Optional) The region of the COS bucket. It supports environment variables TENCENTCLOUD_REGION.
        :param secret_id: (experimental) (Optional) Secret id of Tencent Cloud. It supports environment variables TENCENTCLOUD_SECRET_ID.
        :param secret_key: (experimental) (Optional) Secret key of Tencent Cloud. It supports environment variables TENCENTCLOUD_SECRET_KEY.
        :param security_token: (experimental) (Optional) TencentCloud Security Token of temporary access credentials. It supports environment variables TENCENTCLOUD_SECURITY_TOKEN.

        :stability: experimental
        '''
        if isinstance(assume_role, dict):
            assume_role = CosBackendAssumeRole(**assume_role)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2304a07789ee803e0da927f40176e5d3e1f3c0d59cd9af80ba83c55b982e7603)
            check_type(argname="argument defaults", value=defaults, expected_type=type_hints["defaults"])
            check_type(argname="argument workspace", value=workspace, expected_type=type_hints["workspace"])
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument accelerate", value=accelerate, expected_type=type_hints["accelerate"])
            check_type(argname="argument acl", value=acl, expected_type=type_hints["acl"])
            check_type(argname="argument assume_role", value=assume_role, expected_type=type_hints["assume_role"])
            check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
            check_type(argname="argument encrypt", value=encrypt, expected_type=type_hints["encrypt"])
            check_type(argname="argument endpoint", value=endpoint, expected_type=type_hints["endpoint"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument secret_id", value=secret_id, expected_type=type_hints["secret_id"])
            check_type(argname="argument secret_key", value=secret_key, expected_type=type_hints["secret_key"])
            check_type(argname="argument security_token", value=security_token, expected_type=type_hints["security_token"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bucket": bucket,
        }
        if defaults is not None:
            self._values["defaults"] = defaults
        if workspace is not None:
            self._values["workspace"] = workspace
        if accelerate is not None:
            self._values["accelerate"] = accelerate
        if acl is not None:
            self._values["acl"] = acl
        if assume_role is not None:
            self._values["assume_role"] = assume_role
        if domain is not None:
            self._values["domain"] = domain
        if encrypt is not None:
            self._values["encrypt"] = encrypt
        if endpoint is not None:
            self._values["endpoint"] = endpoint
        if key is not None:
            self._values["key"] = key
        if prefix is not None:
            self._values["prefix"] = prefix
        if region is not None:
            self._values["region"] = region
        if secret_id is not None:
            self._values["secret_id"] = secret_id
        if secret_key is not None:
            self._values["secret_key"] = secret_key
        if security_token is not None:
            self._values["security_token"] = security_token

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

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

    @builtins.property
    def bucket(self) -> builtins.str:
        '''(experimental) (Required) The name of the COS bucket.

        You shall manually create it first.

        :stability: experimental
        '''
        result = self._values.get("bucket")
        assert result is not None, "Required property 'bucket' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def accelerate(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Whether to enable global Acceleration.

        Defaults to false.

        :stability: experimental
        '''
        result = self._values.get("accelerate")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def acl(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Object ACL to be applied to the state file, allows private and public-read.

        Defaults to private.

        :stability: experimental
        '''
        result = self._values.get("acl")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def assume_role(self) -> typing.Optional[CosBackendAssumeRole]:
        '''(experimental) (Optional) The assume_role block.

        If provided, terraform will attempt to assume this role using the supplied credentials.

        :stability: experimental
        '''
        result = self._values.get("assume_role")
        return typing.cast(typing.Optional[CosBackendAssumeRole], result)

    @builtins.property
    def domain(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The root domain of the API request.

        Defaults to tencentcloudapi.com.
        It supports the environment variable TENCENTCLOUD_DOMAIN.

        :stability: experimental
        '''
        result = self._values.get("domain")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def encrypt(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Whether to enable server side encryption of the state file.

        If it is true, COS will use 'AES256' encryption algorithm to encrypt state file.

        :stability: experimental
        '''
        result = self._values.get("encrypt")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The Custom Endpoint for the COS backend.

        It supports the environment variable TENCENTCLOUD_ENDPOINT.

        :stability: experimental
        '''
        result = self._values.get("endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The path for saving the state file in bucket.

        Defaults to terraform.tfstate.

        :stability: experimental
        '''
        result = self._values.get("key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def prefix(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The directory for saving the state file in bucket.

        Default to "env:".

        :stability: experimental
        '''
        result = self._values.get("prefix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The region of the COS bucket.

        It supports environment variables TENCENTCLOUD_REGION.

        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def secret_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Secret id of Tencent Cloud.

        It supports environment variables TENCENTCLOUD_SECRET_ID.

        :stability: experimental
        '''
        result = self._values.get("secret_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def secret_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Secret key of Tencent Cloud.

        It supports environment variables TENCENTCLOUD_SECRET_KEY.

        :stability: experimental
        '''
        result = self._values.get("secret_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def security_token(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) TencentCloud Security Token of temporary access credentials.

        It supports environment variables TENCENTCLOUD_SECURITY_TOKEN.

        :stability: experimental
        '''
        result = self._values.get("security_token")
        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 "DataTerraformRemoteStateCosConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.EncodingOptions",
    jsii_struct_bases=[],
    name_mapping={"display_hint": "displayHint"},
)
class EncodingOptions:
    def __init__(self, *, display_hint: typing.Optional[builtins.str] = None) -> None:
        '''(experimental) Properties to string encodings.

        :param display_hint: (experimental) A hint for the Token's purpose when stringifying it. Default: - no display hint

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3c69b0b044864f8b81c97d35efcc1b9fd74c61641dec5edfb5df56160a1bda1e)
            check_type(argname="argument display_hint", value=display_hint, expected_type=type_hints["display_hint"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if display_hint is not None:
            self._values["display_hint"] = display_hint

    @builtins.property
    def display_hint(self) -> typing.Optional[builtins.str]:
        '''(experimental) A hint for the Token's purpose when stringifying it.

        :default: - no display hint

        :stability: experimental
        '''
        result = self._values.get("display_hint")
        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 "EncodingOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.FileProvisioner",
    jsii_struct_bases=[],
    name_mapping={
        "destination": "destination",
        "type": "type",
        "connection": "connection",
        "content": "content",
        "source": "source",
    },
)
class FileProvisioner:
    def __init__(
        self,
        *,
        destination: builtins.str,
        type: builtins.str,
        connection: typing.Optional[typing.Union[typing.Union["SSHProvisionerConnection", typing.Dict[builtins.str, typing.Any]], typing.Union["WinrmProvisionerConnection", typing.Dict[builtins.str, typing.Any]]]] = None,
        content: typing.Optional[builtins.str] = None,
        source: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) The file provisioner copies files or directories from the machine running Terraform to the newly created resource.

        The file provisioner supports both ssh and winrm type connections.

        See {@link https://developer.hashicorp.com/terraform/language/resources/provisioners/file file}

        :param destination: (experimental) The source file or directory. Specify it either relative to the current working directory or as an absolute path. This argument cannot be combined with content.
        :param type: 
        :param connection: (experimental) Most provisioners require access to the remote resource via SSH or WinRM and expect a nested connection block with details about how to connect.
        :param content: (experimental) The destination path to write to on the remote system. See Destination Paths below for more information.
        :param source: (experimental) The direct content to copy on the destination. If destination is a file, the content will be written on that file. In case of a directory, a file named tf-file-content is created inside that directory. We recommend using a file as the destination when using content. This argument cannot be combined with source.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ab303a023458b5bb7912501c8cdb6bc5f9cce568e0837095a1be589e9a41d882)
            check_type(argname="argument destination", value=destination, expected_type=type_hints["destination"])
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument connection", value=connection, expected_type=type_hints["connection"])
            check_type(argname="argument content", value=content, expected_type=type_hints["content"])
            check_type(argname="argument source", value=source, expected_type=type_hints["source"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "destination": destination,
            "type": type,
        }
        if connection is not None:
            self._values["connection"] = connection
        if content is not None:
            self._values["content"] = content
        if source is not None:
            self._values["source"] = source

    @builtins.property
    def destination(self) -> builtins.str:
        '''(experimental) The source file or directory.

        Specify it either relative to the current working directory or as an absolute path.
        This argument cannot be combined with content.

        :stability: experimental
        '''
        result = self._values.get("destination")
        assert result is not None, "Required property 'destination' is missing"
        return typing.cast(builtins.str, result)

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

    @builtins.property
    def connection(
        self,
    ) -> typing.Optional[typing.Union["SSHProvisionerConnection", "WinrmProvisionerConnection"]]:
        '''(experimental) Most provisioners require access to the remote resource via SSH or WinRM and expect a nested connection block with details about how to connect.

        :stability: experimental
        '''
        result = self._values.get("connection")
        return typing.cast(typing.Optional[typing.Union["SSHProvisionerConnection", "WinrmProvisionerConnection"]], result)

    @builtins.property
    def content(self) -> typing.Optional[builtins.str]:
        '''(experimental) The destination path to write to on the remote system.

        See Destination Paths below for more information.

        :stability: experimental
        '''
        result = self._values.get("content")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def source(self) -> typing.Optional[builtins.str]:
        '''(experimental) The direct content to copy on the destination.

        If destination is a file, the content will be written on that file.
        In case of a directory, a file named tf-file-content is created inside that directory.
        We recommend using a file as the destination when using content.
        This argument cannot be combined with source.

        :stability: experimental
        '''
        result = self._values.get("source")
        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 "FileProvisioner(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class FnGenerated(metaclass=jsii.JSIIMeta, jsii_type="cdktn.FnGenerated"):
    '''
    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="abs")
    @builtins.classmethod
    def abs(cls, num: jsii.Number) -> jsii.Number:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/abs abs} returns the absolute value of the given number. In other words, if the number is zero or positive then it is returned as-is, but if it is negative then it is multiplied by -1 to make it positive before returning it.

        :param num: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9d39df44f39af33a9f138dadfb4600241b9c63fbdf6845d040a55d84abb1d0cc)
            check_type(argname="argument num", value=num, expected_type=type_hints["num"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "abs", [num]))

    @jsii.member(jsii_name="abspath")
    @builtins.classmethod
    def abspath(cls, path: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/abspath abspath} takes a string containing a filesystem path and converts it to an absolute path. That is, if the path is not absolute, it will be joined with the current working directory.

        :param path: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ba21fb8c11024a5220a7394d22972478540f66c3ce849afbde6e2ac93ae69cca)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "abspath", [path]))

    @jsii.member(jsii_name="alltrue")
    @builtins.classmethod
    def alltrue(cls, list: typing.Sequence[typing.Any]) -> "IResolvable":
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/alltrue alltrue} returns ``true`` if all elements in a given collection are ``true`` or ``"true"``. It also returns ``true`` if the collection is empty.

        :param list: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bff9bc764ddd56233d30866b6e3715a167f1eb1127fe0de24f327a5fe5a8aed2)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
        return typing.cast("IResolvable", jsii.sinvoke(cls, "alltrue", [list]))

    @jsii.member(jsii_name="anytrue")
    @builtins.classmethod
    def anytrue(cls, list: typing.Sequence[typing.Any]) -> "IResolvable":
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/anytrue anytrue} returns ``true`` if any element in a given collection is ``true`` or ``"true"``. It also returns ``false`` if the collection is empty.

        :param list: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__be8e4a30e9f8a8b02dd66c097fe93102b0c05c75d53e4721e5b86eae1d7c8d98)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
        return typing.cast("IResolvable", jsii.sinvoke(cls, "anytrue", [list]))

    @jsii.member(jsii_name="base64decode")
    @builtins.classmethod
    def base64decode(cls, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/base64decode base64decode} takes a string containing a Base64 character sequence and returns the original string.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__998e027e17e59814b47c0757c320cede4d31a6dd4cf086c41cc35f9560e2764d)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "base64decode", [str]))

    @jsii.member(jsii_name="base64encode")
    @builtins.classmethod
    def base64encode(cls, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/base64encode base64encode} applies Base64 encoding to a string.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__02abfac1eb20205fc70ccdc08f75d906d032bd84662fa7ec0867bd656e1ac9ad)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "base64encode", [str]))

    @jsii.member(jsii_name="base64gzip")
    @builtins.classmethod
    def base64gzip(cls, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/base64gzip base64gzip} compresses a string with gzip and then encodes the result in Base64 encoding.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d0f038a6c25c1946d9e7fd8bea7c6fac9311e2733800d46904f8ea4a79360ab3)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "base64gzip", [str]))

    @jsii.member(jsii_name="base64sha256")
    @builtins.classmethod
    def base64sha256(cls, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/base64sha256 base64sha256} computes the SHA256 hash of a given string and encodes it with Base64. This is not equivalent to ``base64encode(sha256("test"))`` since ``sha256()`` returns hexadecimal representation.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__23f76e127826aa06992eb357d4ab4c6464b83347ffecf57d47b40a25869ab007)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "base64sha256", [str]))

    @jsii.member(jsii_name="base64sha512")
    @builtins.classmethod
    def base64sha512(cls, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/base64sha512 base64sha512} computes the SHA512 hash of a given string and encodes it with Base64. This is not equivalent to ``base64encode(sha512("test"))`` since ``sha512()`` returns hexadecimal representation.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d40720f5f11756b1870116400f157b83b3e941ddf51a29c93e7371c89d0525af)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "base64sha512", [str]))

    @jsii.member(jsii_name="basename")
    @builtins.classmethod
    def basename(cls, path: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/basename basename} takes a string containing a filesystem path and removes all except the last portion from it.

        :param path: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2a618ab1e1b552e85e8e5cb20907b57869a42e473a91b8b17e6f6a3ae959557e)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "basename", [path]))

    @jsii.member(jsii_name="can")
    @builtins.classmethod
    def can(cls, expression: typing.Any) -> "IResolvable":
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/can can} evaluates the given expression and returns a boolean value indicating whether the expression produced a result without any errors.

        :param expression: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f8ac795e94d3de88324d8a9c5e34884489d6db2e3ebd156cae240bec26f28d5e)
            check_type(argname="argument expression", value=expression, expected_type=type_hints["expression"])
        return typing.cast("IResolvable", jsii.sinvoke(cls, "can", [expression]))

    @jsii.member(jsii_name="ceil")
    @builtins.classmethod
    def ceil(cls, num: jsii.Number) -> jsii.Number:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/ceil ceil} returns the closest whole number that is greater than or equal to the given value, which may be a fraction.

        :param num: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e72f66889a8998809228fb82f8d1850c8a21d4a9c64a6c0f7020fdd4f1c4a67a)
            check_type(argname="argument num", value=num, expected_type=type_hints["num"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "ceil", [num]))

    @jsii.member(jsii_name="chomp")
    @builtins.classmethod
    def chomp(cls, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/chomp chomp} removes newline characters at the end of a string.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9bcae7faf7dac340573514517ebe3beb00ca43680142feaed9843f14b08a67b2)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "chomp", [str]))

    @jsii.member(jsii_name="chunklist")
    @builtins.classmethod
    def chunklist(
        cls,
        list: typing.Sequence[typing.Any],
        size: jsii.Number,
    ) -> typing.List[builtins.str]:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/chunklist chunklist} splits a single list into fixed-size chunks, returning a list of lists.

        :param list: -
        :param size: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ce0af7ebdc0cf508f7928458989ada25777d413bb900b9f7da33fe5640afd874)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
            check_type(argname="argument size", value=size, expected_type=type_hints["size"])
        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "chunklist", [list, size]))

    @jsii.member(jsii_name="cidrhost")
    @builtins.classmethod
    def cidrhost(cls, prefix: builtins.str, hostnum: jsii.Number) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/cidrhost cidrhost} calculates a full host IP address for a given host number within a given IP network address prefix.

        :param prefix: -
        :param hostnum: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__529619d82d9f1147d808de320e57f4fbd7d322ff30fd9349288f46f6354d7e7a)
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
            check_type(argname="argument hostnum", value=hostnum, expected_type=type_hints["hostnum"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "cidrhost", [prefix, hostnum]))

    @jsii.member(jsii_name="cidrnetmask")
    @builtins.classmethod
    def cidrnetmask(cls, prefix: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/cidrnetmask cidrnetmask} converts an IPv4 address prefix given in CIDR notation into a subnet mask address.

        :param prefix: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__74edf5068858280728e4be33504bcbfdb6be48361b2eef0853c20e13e98e685e)
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "cidrnetmask", [prefix]))

    @jsii.member(jsii_name="cidrsubnet")
    @builtins.classmethod
    def cidrsubnet(
        cls,
        prefix: builtins.str,
        newbits: jsii.Number,
        netnum: jsii.Number,
    ) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/cidrsubnet cidrsubnet} calculates a subnet address within given IP network address prefix.

        :param prefix: -
        :param newbits: -
        :param netnum: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8053cd40b5a4b7afeab73a145662f234239aa829327ed523d937ac3766ac1a0f)
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
            check_type(argname="argument newbits", value=newbits, expected_type=type_hints["newbits"])
            check_type(argname="argument netnum", value=netnum, expected_type=type_hints["netnum"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "cidrsubnet", [prefix, newbits, netnum]))

    @jsii.member(jsii_name="cidrsubnets")
    @builtins.classmethod
    def cidrsubnets(
        cls,
        prefix: builtins.str,
        newbits: typing.Sequence[jsii.Number],
    ) -> typing.List[builtins.str]:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/cidrsubnets cidrsubnets} calculates a sequence of consecutive IP address ranges within a particular CIDR prefix.

        :param prefix: -
        :param newbits: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__57b4782f64537c6c60365d594695e57257e2a7d4179a43b6fce8f7ec298bc4fa)
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
            check_type(argname="argument newbits", value=newbits, expected_type=type_hints["newbits"])
        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "cidrsubnets", [prefix, newbits]))

    @jsii.member(jsii_name="coalesce")
    @builtins.classmethod
    def coalesce(cls, vals: typing.Sequence[typing.Any]) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/coalesce coalesce} takes any number of arguments and returns the first one that isn't null or an empty string.

        :param vals: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1fb3aef9d4b76771241df5534ce91e1875f197b03be98c3f14d6445f3a23cdeb)
            check_type(argname="argument vals", value=vals, expected_type=type_hints["vals"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "coalesce", [vals]))

    @jsii.member(jsii_name="coalescelist")
    @builtins.classmethod
    def coalescelist(cls, vals: typing.Sequence[typing.Any]) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/coalescelist coalescelist} takes any number of list arguments and returns the first one that isn't empty.

        :param vals: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b04b60da3fa9a1a3437c8fc0acc8588649e4444cf3dea4ea414ceb0d0a79206f)
            check_type(argname="argument vals", value=vals, expected_type=type_hints["vals"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "coalescelist", [vals]))

    @jsii.member(jsii_name="compact")
    @builtins.classmethod
    def compact(cls, list: typing.Sequence[builtins.str]) -> typing.List[builtins.str]:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/compact compact} takes a list of strings and returns a new list with any empty string elements removed.

        :param list: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__313e8bb907f8b59977e0e1bf117718fddc5fcaf1085486c36a4c392e3b10be1b)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "compact", [list]))

    @jsii.member(jsii_name="concat")
    @builtins.classmethod
    def concat(cls, seqs: typing.Sequence[typing.Any]) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/concat concat} takes two or more lists and combines them into a single list.

        :param seqs: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e4c76fb1459acafc104bd4d08fee28d38cc6a487c1950b0c082b335d664ca3a6)
            check_type(argname="argument seqs", value=seqs, expected_type=type_hints["seqs"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "concat", [seqs]))

    @jsii.member(jsii_name="contains")
    @builtins.classmethod
    def contains(cls, list: typing.Any, value: typing.Any) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/contains contains} determines whether a given list or set contains a given single value as one of its elements.

        :param list: -
        :param value: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8bae3d846a2a830f67633e81cda0cf30b6b748e96e0633452450cd441f43a664)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "contains", [list, value]))

    @jsii.member(jsii_name="csvdecode")
    @builtins.classmethod
    def csvdecode(cls, str: builtins.str) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/csvdecode csvdecode} decodes a string containing CSV-formatted data and produces a list of maps representing that data.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__756b0544b55958bb4aabfdf98cc4e68db1685b1dc491049e4d8c06712ddc0a99)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "csvdecode", [str]))

    @jsii.member(jsii_name="dirname")
    @builtins.classmethod
    def dirname(cls, path: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/dirname dirname} takes a string containing a filesystem path and removes the last portion from it.

        :param path: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__216a0deb96cbd708c7ac150c86b1c43d34652746c63c0bdda213c84d44a1de40)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "dirname", [path]))

    @jsii.member(jsii_name="distinct")
    @builtins.classmethod
    def distinct(cls, list: typing.Sequence[typing.Any]) -> typing.List[builtins.str]:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/distinct distinct} takes a list and returns a new list with any duplicate elements removed.

        :param list: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e2822c87a26275696b738df1a2af7802c9c6d767bb81f79d2f6296bb9c3c059d)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "distinct", [list]))

    @jsii.member(jsii_name="element")
    @builtins.classmethod
    def element(cls, list: typing.Any, index: jsii.Number) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/element element} retrieves a single element from a list.

        :param list: -
        :param index: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__07d8f09b529f219ed3912d33fd482f5ff7e7b71765b8b6b48f26e85f0932139d)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
            check_type(argname="argument index", value=index, expected_type=type_hints["index"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "element", [list, index]))

    @jsii.member(jsii_name="endswith")
    @builtins.classmethod
    def endswith(cls, str: builtins.str, suffix: builtins.str) -> "IResolvable":
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/endswith endswith} takes two values: a string to check and a suffix string. The function returns true if the first string ends with that exact suffix.

        :param str: -
        :param suffix: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8c7d43f497a8f9c49be857a27c87f204a9cb9da33c7120fff2f509c58bbca5ab)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
            check_type(argname="argument suffix", value=suffix, expected_type=type_hints["suffix"])
        return typing.cast("IResolvable", jsii.sinvoke(cls, "endswith", [str, suffix]))

    @jsii.member(jsii_name="file")
    @builtins.classmethod
    def file(cls, path: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/file file} reads the contents of a file at the given path and returns them as a string.

        :param path: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__253bf4a41ad5707e0f0d2e1271898c9b53aad5c3a4acbbee0bdb2910475c8aeb)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "file", [path]))

    @jsii.member(jsii_name="filebase64")
    @builtins.classmethod
    def filebase64(cls, path: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/filebase64 filebase64} reads the contents of a file at the given path and returns them as a base64-encoded string.

        :param path: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a56c3ba2b780ecd1862370a3fd01036395eef56eae315e139bfebc0a22fbb1dd)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "filebase64", [path]))

    @jsii.member(jsii_name="filebase64sha256")
    @builtins.classmethod
    def filebase64sha256(cls, path: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/filebase64sha256 filebase64sha256} is a variant of ``base64sha256`` that hashes the contents of a given file rather than a literal string.

        :param path: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9f0b6544e2a236011539c958aa0e6f91df4141e49046a6084a93f565ad681293)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "filebase64sha256", [path]))

    @jsii.member(jsii_name="filebase64sha512")
    @builtins.classmethod
    def filebase64sha512(cls, path: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/filebase64sha512 filebase64sha512} is a variant of ``base64sha512`` that hashes the contents of a given file rather than a literal string.

        :param path: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5b046df22ec8dfbf54317942ae8564617c69149a017c00e2a34e3fbeb837cf0f)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "filebase64sha512", [path]))

    @jsii.member(jsii_name="fileexists")
    @builtins.classmethod
    def fileexists(cls, path: builtins.str) -> "IResolvable":
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/fileexists fileexists} determines whether a file exists at a given path.

        :param path: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dc3f029f21052b34a0b81debb207dcc4fc63205ba85e484101cdb0838d85ceb9)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        return typing.cast("IResolvable", jsii.sinvoke(cls, "fileexists", [path]))

    @jsii.member(jsii_name="filemd5")
    @builtins.classmethod
    def filemd5(cls, path: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/filemd5 filemd5} is a variant of ``md5`` that hashes the contents of a given file rather than a literal string.

        :param path: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1a524b7b79f9f8470eaa1fddf29235692bb09ffaf052de5ae77ef70f19a93b42)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "filemd5", [path]))

    @jsii.member(jsii_name="fileset")
    @builtins.classmethod
    def fileset(
        cls,
        path: builtins.str,
        pattern: builtins.str,
    ) -> typing.List[builtins.str]:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/fileset fileset} enumerates a set of regular file names given a path and pattern. The path is automatically removed from the resulting set of file names and any result still containing path separators always returns forward slash (``/``) as the path separator for cross-system compatibility.

        :param path: -
        :param pattern: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c845652bb5feafb3f21b971d5630d20d055362918c70686bdf734e224b8c6548)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
            check_type(argname="argument pattern", value=pattern, expected_type=type_hints["pattern"])
        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "fileset", [path, pattern]))

    @jsii.member(jsii_name="filesha1")
    @builtins.classmethod
    def filesha1(cls, path: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/filesha1 filesha1} is a variant of ``sha1`` that hashes the contents of a given file rather than a literal string.

        :param path: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7ad048895fe23417decb94858c145086a417521a6f14f1e62b36e4b53e3188ae)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "filesha1", [path]))

    @jsii.member(jsii_name="filesha256")
    @builtins.classmethod
    def filesha256(cls, path: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/filesha256 filesha256} is a variant of ``sha256`` that hashes the contents of a given file rather than a literal string.

        :param path: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__540beff57b82e62950d07038481589e4904850c42faa46ac82f9f849d340015c)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "filesha256", [path]))

    @jsii.member(jsii_name="filesha512")
    @builtins.classmethod
    def filesha512(cls, path: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/filesha512 filesha512} is a variant of ``sha512`` that hashes the contents of a given file rather than a literal string.

        :param path: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2e19051510d84f7410973d99fb87971bca7462eb0013bbb2aaf456ef0218249e)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "filesha512", [path]))

    @jsii.member(jsii_name="flatten")
    @builtins.classmethod
    def flatten(cls, list: typing.Any) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/flatten flatten} takes a list and replaces any elements that are lists with a flattened sequence of the list contents.

        :param list: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a459f1ca7ee45011b65c6d94168428f66add3e2ae90af5e7dca1ee018d71f199)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "flatten", [list]))

    @jsii.member(jsii_name="floor")
    @builtins.classmethod
    def floor(cls, num: jsii.Number) -> jsii.Number:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/floor floor} returns the closest whole number that is less than or equal to the given value, which may be a fraction.

        :param num: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8d933dd9227ba0b3dbd79c9278eb9c0e5ba99a05487e194954a30947e3f2395b)
            check_type(argname="argument num", value=num, expected_type=type_hints["num"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "floor", [num]))

    @jsii.member(jsii_name="format")
    @builtins.classmethod
    def format(
        cls,
        format: builtins.str,
        args: typing.Sequence[typing.Any],
    ) -> typing.Any:
        '''(experimental) The {@link https://developer.hashicorp.com/terraform/language/functions/format format} function produces a string by formatting a number of other values according to a specification string. It is similar to the ``printf`` function in C, and other similar functions in other programming languages.

        :param format: -
        :param args: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2000666ae0491b73893edc10d30e7d1c728288102936b3bee9b0d95d1f4982ab)
            check_type(argname="argument format", value=format, expected_type=type_hints["format"])
            check_type(argname="argument args", value=args, expected_type=type_hints["args"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "format", [format, args]))

    @jsii.member(jsii_name="formatdate")
    @builtins.classmethod
    def formatdate(cls, format: builtins.str, time: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/formatdate formatdate} converts a timestamp into a different time format.

        :param format: -
        :param time: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__61072dada83bcad8479193ae443000262d05d69dfab8a2bbe87695072d3623e4)
            check_type(argname="argument format", value=format, expected_type=type_hints["format"])
            check_type(argname="argument time", value=time, expected_type=type_hints["time"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "formatdate", [format, time]))

    @jsii.member(jsii_name="formatlist")
    @builtins.classmethod
    def formatlist(
        cls,
        format: builtins.str,
        args: typing.Sequence[typing.Any],
    ) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/formatlist formatlist} produces a list of strings by formatting a number of other values according to a specification string.

        :param format: -
        :param args: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__973e0cee58d04843b1ec115811f7414596cb1cde6d39cdb210930386e2790a97)
            check_type(argname="argument format", value=format, expected_type=type_hints["format"])
            check_type(argname="argument args", value=args, expected_type=type_hints["args"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "formatlist", [format, args]))

    @jsii.member(jsii_name="indent")
    @builtins.classmethod
    def indent(cls, spaces: jsii.Number, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/indent indent} adds a given number of spaces to the beginnings of all but the first line in a given multi-line string.

        :param spaces: -
        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__71f3ca7e1863451b977fbb3109b938b7499bda67954b0ac6ccb2a3e98771199f)
            check_type(argname="argument spaces", value=spaces, expected_type=type_hints["spaces"])
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "indent", [spaces, str]))

    @jsii.member(jsii_name="index")
    @builtins.classmethod
    def index(cls, list: typing.Any, value: typing.Any) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/index index} finds the element index for a given value in a list.

        :param list: -
        :param value: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a31158cedb446b33ec6f3c3dac38a9ec7b93b1afe0bca7558a29c67b6ad9b492)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "index", [list, value]))

    @jsii.member(jsii_name="jsondecode")
    @builtins.classmethod
    def jsondecode(cls, str: builtins.str) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/jsondecode jsondecode} interprets a given string as JSON, returning a representation of the result of decoding that string.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4da3c22cb9d91206c59cc5a07022f4ccbb9381c1801e12f2da88f42116500f53)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "jsondecode", [str]))

    @jsii.member(jsii_name="jsonencode")
    @builtins.classmethod
    def jsonencode(cls, val: typing.Any) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/jsonencode jsonencode} encodes a given value to a string using JSON syntax.

        :param val: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ea20d6d2d6132cb371ed5e95069019e3b4d40a347495bb54c035981b027a1d87)
            check_type(argname="argument val", value=val, expected_type=type_hints["val"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "jsonencode", [val]))

    @jsii.member(jsii_name="keys")
    @builtins.classmethod
    def keys(cls, input_map: typing.Any) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/keys keys} takes a map and returns a list containing the keys from that map.

        :param input_map: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__29fb631cced10ad8a27db65a69a22c9cd494e10a9064e2c450a12f2583d13c80)
            check_type(argname="argument input_map", value=input_map, expected_type=type_hints["input_map"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "keys", [input_map]))

    @jsii.member(jsii_name="lengthOf")
    @builtins.classmethod
    def length_of(cls, value: typing.Any) -> jsii.Number:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/length length} determines the length of a given list, map, or string.

        :param value: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__052ed58651630e3f0096ca11dc790d6eb6c6d16086cec4df2693eda0b5e67f1f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "lengthOf", [value]))

    @jsii.member(jsii_name="log")
    @builtins.classmethod
    def log(cls, num: jsii.Number, base: jsii.Number) -> jsii.Number:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/log log} returns the logarithm of a given number in a given base.

        :param num: -
        :param base: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d347f3e24a82f256e95a4a7130bbde6ea7054b8da91a367bec8c368054b0c13f)
            check_type(argname="argument num", value=num, expected_type=type_hints["num"])
            check_type(argname="argument base", value=base, expected_type=type_hints["base"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "log", [num, base]))

    @jsii.member(jsii_name="lower")
    @builtins.classmethod
    def lower(cls, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/lower lower} converts all cased letters in the given string to lowercase.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ec3e9c01db6bc50d5253594907ee4ff91a7fc0efa6bba9527f1eaa654bfef0ae)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "lower", [str]))

    @jsii.member(jsii_name="matchkeys")
    @builtins.classmethod
    def matchkeys(
        cls,
        values: typing.Sequence[typing.Any],
        keys: typing.Sequence[typing.Any],
        searchset: typing.Sequence[typing.Any],
    ) -> typing.List[builtins.str]:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/matchkeys matchkeys} constructs a new list by taking a subset of elements from one list whose indexes match the corresponding indexes of values in another list.

        :param values: -
        :param keys: -
        :param searchset: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__72fa40d9c8291cef8c5c0c116db9d1d8fbaa1dbfe3bb272f64e90eda4eab93c6)
            check_type(argname="argument values", value=values, expected_type=type_hints["values"])
            check_type(argname="argument keys", value=keys, expected_type=type_hints["keys"])
            check_type(argname="argument searchset", value=searchset, expected_type=type_hints["searchset"])
        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "matchkeys", [values, keys, searchset]))

    @jsii.member(jsii_name="max")
    @builtins.classmethod
    def max(cls, numbers: typing.Sequence[jsii.Number]) -> jsii.Number:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/max max} takes one or more numbers and returns the greatest number from the set.

        :param numbers: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4a7a3d3fee4cf879671a99e076b6d8daabd4834ce73543a594d04d87082fe11c)
            check_type(argname="argument numbers", value=numbers, expected_type=type_hints["numbers"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "max", [numbers]))

    @jsii.member(jsii_name="md5")
    @builtins.classmethod
    def md5(cls, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/md5 md5} computes the MD5 hash of a given string and encodes it with hexadecimal digits.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0d658d178f253ff53c376c21175afaac99f0a5e9e64d461ae5b7279d3a717dfa)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "md5", [str]))

    @jsii.member(jsii_name="merge")
    @builtins.classmethod
    def merge(cls, maps: typing.Sequence[typing.Any]) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/merge merge} takes an arbitrary number of maps or objects, and returns a single map or object that contains a merged set of elements from all arguments.

        :param maps: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__875d410edf57046cddd39cbc1d66c4fbadb3ff8e5c68486f3be0707d658320ec)
            check_type(argname="argument maps", value=maps, expected_type=type_hints["maps"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "merge", [maps]))

    @jsii.member(jsii_name="min")
    @builtins.classmethod
    def min(cls, numbers: typing.Sequence[jsii.Number]) -> jsii.Number:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/min min} takes one or more numbers and returns the smallest number from the set.

        :param numbers: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__03cf066cdfb04be5ee0e87ad28b4622b7b653fd9f256f03fc8b9fa5ed680b42b)
            check_type(argname="argument numbers", value=numbers, expected_type=type_hints["numbers"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "min", [numbers]))

    @jsii.member(jsii_name="nonsensitive")
    @builtins.classmethod
    def nonsensitive(cls, value: typing.Any) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/nonsensitive nonsensitive} takes a sensitive value and returns a copy of that value with the sensitive marking removed, thereby exposing the sensitive value.

        :param value: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f54e546910dc0fa0068231339fdd41f1dfe84ebd31c205953e0c5146803d135f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "nonsensitive", [value]))

    @jsii.member(jsii_name="one")
    @builtins.classmethod
    def one(cls, list: typing.Any) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/one one} takes a list, set, or tuple value with either zero or one elements. If the collection is empty, ``one`` returns ``null``. Otherwise, ``one`` returns the first element. If there are two or more elements then ``one`` will return an error.

        :param list: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aff1345cc20e64d27d35157843e3b68c36a543546699881ef8a251ea4b1f5192)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "one", [list]))

    @jsii.member(jsii_name="parseint")
    @builtins.classmethod
    def parseint(cls, number: typing.Any, base: jsii.Number) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/parseint parseint} parses the given string as a representation of an integer in the specified base and returns the resulting number. The base must be between 2 and 62 inclusive.

        :param number: -
        :param base: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8dd4adb0e316237678faec6d594f7674a44ba5b5f9a7817e28c8dd7ecb4eb629)
            check_type(argname="argument number", value=number, expected_type=type_hints["number"])
            check_type(argname="argument base", value=base, expected_type=type_hints["base"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "parseint", [number, base]))

    @jsii.member(jsii_name="pathexpand")
    @builtins.classmethod
    def pathexpand(cls, path: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/pathexpand pathexpand} takes a filesystem path that might begin with a ``~`` segment, and if so it replaces that segment with the current user's home directory path.

        :param path: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__12730216beb516b2b90cf63330bd0913bb713b1d5e39def768f23ed608799865)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "pathexpand", [path]))

    @jsii.member(jsii_name="plantimestamp")
    @builtins.classmethod
    def plantimestamp(cls) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/plantimestamp plantimestamp} returns a UTC timestamp string in `RFC 3339 <https://tools.ietf.org/html/rfc3339>`_ format, fixed to a constant time representing the time of the plan.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sinvoke(cls, "plantimestamp", []))

    @jsii.member(jsii_name="pow")
    @builtins.classmethod
    def pow(cls, num: jsii.Number, power: jsii.Number) -> jsii.Number:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/pow pow} calculates an exponent, by raising its first argument to the power of the second argument.

        :param num: -
        :param power: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bcf07285e3a0e5740c6f713a638e085085e2d95fa1819660e59fc0ab82b1f4a3)
            check_type(argname="argument num", value=num, expected_type=type_hints["num"])
            check_type(argname="argument power", value=power, expected_type=type_hints["power"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "pow", [num, power]))

    @jsii.member(jsii_name="regex")
    @builtins.classmethod
    def regex(cls, pattern: builtins.str, str: builtins.str) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/regex regex} applies a `regular expression <https://en.wikipedia.org/wiki/Regular_expression>`_ to a string and returns the matching substrings.

        :param pattern: -
        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4341a46c04854f74e844b9dd491e8773bb03582a3e30649b9b2545803e487fda)
            check_type(argname="argument pattern", value=pattern, expected_type=type_hints["pattern"])
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "regex", [pattern, str]))

    @jsii.member(jsii_name="regexall")
    @builtins.classmethod
    def regexall(
        cls,
        pattern: builtins.str,
        str: builtins.str,
    ) -> typing.List[builtins.str]:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/regexall regexall} applies a `regular expression <https://en.wikipedia.org/wiki/Regular_expression>`_ to a string and returns a list of all matches.

        :param pattern: -
        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6a55d366b77e886626d7551bfa18d68cdecf81bae060386b8fab43577627d220)
            check_type(argname="argument pattern", value=pattern, expected_type=type_hints["pattern"])
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "regexall", [pattern, str]))

    @jsii.member(jsii_name="replace")
    @builtins.classmethod
    def replace(
        cls,
        str: builtins.str,
        substr: builtins.str,
        replace: builtins.str,
    ) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/replace replace} searches a given string for another given substring, and replaces each occurrence with a given replacement string.

        :param str: -
        :param substr: -
        :param replace: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e36b1bf54c166721cb1a0fb4234e883551d4f2b91fc6d2dde7b95a5b2b169ebf)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
            check_type(argname="argument substr", value=substr, expected_type=type_hints["substr"])
            check_type(argname="argument replace", value=replace, expected_type=type_hints["replace"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "replace", [str, substr, replace]))

    @jsii.member(jsii_name="reverse")
    @builtins.classmethod
    def reverse(cls, list: typing.Any) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/reverse reverse} takes a sequence and produces a new sequence of the same length with all of the same elements as the given sequence but in reverse order.

        :param list: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__071a1a2d4e74f9a0b01e39f900c50e30f187bf7c2cde92dd81aacfd3f5c059a1)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "reverse", [list]))

    @jsii.member(jsii_name="rsadecrypt")
    @builtins.classmethod
    def rsadecrypt(
        cls,
        ciphertext: builtins.str,
        privatekey: builtins.str,
    ) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/rsadecrypt rsadecrypt} decrypts an RSA-encrypted ciphertext, returning the corresponding cleartext.

        :param ciphertext: -
        :param privatekey: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__51aa25e5e94a77d383c37dc351212cf58c5b96452abf53a086d2b55dcd869614)
            check_type(argname="argument ciphertext", value=ciphertext, expected_type=type_hints["ciphertext"])
            check_type(argname="argument privatekey", value=privatekey, expected_type=type_hints["privatekey"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "rsadecrypt", [ciphertext, privatekey]))

    @jsii.member(jsii_name="sensitive")
    @builtins.classmethod
    def sensitive(cls, value: typing.Any) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/sensitive sensitive} takes any value and returns a copy of it marked so that Terraform will treat it as sensitive, with the same meaning and behavior as for `sensitive input variables </terraform/language/values/variables#suppressing-values-in-cli-output>`_.

        :param value: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__21955c1965dc21beffcde9636967cc3c71cd154d00a3f0c9575355f3f524ea86)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "sensitive", [value]))

    @jsii.member(jsii_name="setintersection")
    @builtins.classmethod
    def setintersection(
        cls,
        first_set: typing.Sequence[typing.Any],
        other_sets: typing.Sequence[typing.Sequence[typing.Any]],
    ) -> typing.List[builtins.str]:
        '''(experimental) The {@link https://developer.hashicorp.com/terraform/language/functions/setintersection setintersection} function takes multiple sets and produces a single set containing only the elements that all of the given sets have in common. In other words, it computes the `intersection <https://en.wikipedia.org/wiki/Intersection_(set_theory)>`_ of the sets.

        :param first_set: -
        :param other_sets: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c9300381230bd7bd03e82d943a4078da740f4e904623f2e86fc03cb8c13a743c)
            check_type(argname="argument first_set", value=first_set, expected_type=type_hints["first_set"])
            check_type(argname="argument other_sets", value=other_sets, expected_type=type_hints["other_sets"])
        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "setintersection", [first_set, other_sets]))

    @jsii.member(jsii_name="setproduct")
    @builtins.classmethod
    def setproduct(cls, sets: typing.Sequence[typing.Any]) -> typing.Any:
        '''(experimental) The {@link https://developer.hashicorp.com/terraform/language/functions/setproduct setproduct} function finds all of the possible combinations of elements from all of the given sets by computing the `Cartesian product <https://en.wikipedia.org/wiki/Cartesian_product>`_.

        :param sets: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f67d797ac1f8be835252f345304c90c8666c043efb3c3c75e22dcaad0d09afac)
            check_type(argname="argument sets", value=sets, expected_type=type_hints["sets"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "setproduct", [sets]))

    @jsii.member(jsii_name="setsubtract")
    @builtins.classmethod
    def setsubtract(
        cls,
        a: typing.Sequence[typing.Any],
        b: typing.Sequence[typing.Any],
    ) -> typing.List[builtins.str]:
        '''(experimental) The {@link https://developer.hashicorp.com/terraform/language/functions/setsubtract setsubtract} function returns a new set containing the elements from the first set that are not present in the second set. In other words, it computes the `relative complement <https://en.wikipedia.org/wiki/Complement_(set_theory)#Relative_complement>`_ of the second set.

        :param a: -
        :param b: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4c423ebfa20385b5c70e2339eaa3d326bc619db5874a494b0d6bb15f3ee889c3)
            check_type(argname="argument a", value=a, expected_type=type_hints["a"])
            check_type(argname="argument b", value=b, expected_type=type_hints["b"])
        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "setsubtract", [a, b]))

    @jsii.member(jsii_name="setunion")
    @builtins.classmethod
    def setunion(
        cls,
        first_set: typing.Sequence[typing.Any],
        other_sets: typing.Sequence[typing.Sequence[typing.Any]],
    ) -> typing.List[builtins.str]:
        '''(experimental) The {@link https://developer.hashicorp.com/terraform/language/functions/setunion setunion} function takes multiple sets and produces a single set containing the elements from all of the given sets. In other words, it computes the `union <https://en.wikipedia.org/wiki/Union_(set_theory)>`_ of the sets.

        :param first_set: -
        :param other_sets: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2a0883bd0c8081e52ec7e1744943133e498e6eb78c26b051476c5ea596d3eda3)
            check_type(argname="argument first_set", value=first_set, expected_type=type_hints["first_set"])
            check_type(argname="argument other_sets", value=other_sets, expected_type=type_hints["other_sets"])
        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "setunion", [first_set, other_sets]))

    @jsii.member(jsii_name="sha1")
    @builtins.classmethod
    def sha1(cls, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/sha1 sha1} computes the SHA1 hash of a given string and encodes it with hexadecimal digits.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e2acd4b1b786120f23176dc2f03ee51c7f0adb52825001b6d9521f1f12b1ecb5)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "sha1", [str]))

    @jsii.member(jsii_name="sha256")
    @builtins.classmethod
    def sha256(cls, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/sha256 sha256} computes the SHA256 hash of a given string and encodes it with hexadecimal digits.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__549c436e9175a9b7169d844836b8ad568a1636d72e1e193aea1e8d71ea0f1779)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "sha256", [str]))

    @jsii.member(jsii_name="sha512")
    @builtins.classmethod
    def sha512(cls, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/sha512 sha512} computes the SHA512 hash of a given string and encodes it with hexadecimal digits.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6844974552c91f0a1c1af20e27cc13c539e451e4213f8b7819a8a1323f339e7f)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "sha512", [str]))

    @jsii.member(jsii_name="signum")
    @builtins.classmethod
    def signum(cls, num: jsii.Number) -> jsii.Number:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/signum signum} determines the sign of a number, returning a number between -1 and 1 to represent the sign.

        :param num: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3c9b47c61fe0e3f3ba2c50f3658aa0b64720c6ab5300b336cdc33f0f80a4a127)
            check_type(argname="argument num", value=num, expected_type=type_hints["num"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "signum", [num]))

    @jsii.member(jsii_name="slice")
    @builtins.classmethod
    def slice(
        cls,
        list: typing.Any,
        start_index: jsii.Number,
        end_index: jsii.Number,
    ) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/slice slice} extracts some consecutive elements from within a list.

        :param list: -
        :param start_index: -
        :param end_index: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dedcdb9decab4e97af9b64a0210f9636f941064061e3fb9b502ac4eb0e045c88)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
            check_type(argname="argument start_index", value=start_index, expected_type=type_hints["start_index"])
            check_type(argname="argument end_index", value=end_index, expected_type=type_hints["end_index"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "slice", [list, start_index, end_index]))

    @jsii.member(jsii_name="sort")
    @builtins.classmethod
    def sort(cls, list: typing.Sequence[builtins.str]) -> typing.List[builtins.str]:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/sort sort} takes a list of strings and returns a new list with those strings sorted lexicographically.

        :param list: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f7e36acfec5bc9d460f5fa9ddedceae511c30827e190e7ef1958fd360bcbdb35)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "sort", [list]))

    @jsii.member(jsii_name="split")
    @builtins.classmethod
    def split(
        cls,
        separator: builtins.str,
        str: builtins.str,
    ) -> typing.List[builtins.str]:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/split split} produces a list by dividing a given string at all occurrences of a given separator.

        :param separator: -
        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__719216036507b33fcf6bce96614d42942a5482155ac71300dc9e6d206601bfe0)
            check_type(argname="argument separator", value=separator, expected_type=type_hints["separator"])
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "split", [separator, str]))

    @jsii.member(jsii_name="startswith")
    @builtins.classmethod
    def startswith(cls, str: builtins.str, prefix: builtins.str) -> "IResolvable":
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/startswith startswith} takes two values: a string to check and a prefix string. The function returns true if the string begins with that exact prefix.

        :param str: -
        :param prefix: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a802ae04b2d1e585ab50d0380f4afe47291e7c9e42a5479d0a601a8e27bb87ca)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
        return typing.cast("IResolvable", jsii.sinvoke(cls, "startswith", [str, prefix]))

    @jsii.member(jsii_name="strcontains")
    @builtins.classmethod
    def strcontains(cls, str: builtins.str, substr: builtins.str) -> "IResolvable":
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/strcontains strcontains} takes two values: a string to check and an expected substring. The function returns true if the string has the substring contained within it.

        :param str: -
        :param substr: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8d2e161f20d8df2cbbeda542bcf0d00ef4c3c7c3d102c9abceae20f26e7f49ce)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
            check_type(argname="argument substr", value=substr, expected_type=type_hints["substr"])
        return typing.cast("IResolvable", jsii.sinvoke(cls, "strcontains", [str, substr]))

    @jsii.member(jsii_name="strrev")
    @builtins.classmethod
    def strrev(cls, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/strrev strrev} reverses the characters in a string. Note that the characters are treated as *Unicode characters* (in technical terms, Unicode `grapheme cluster boundaries <https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries>`_ are respected).

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a6593b4505d67333c9ef4d67d39b97640d9cb333ad77a09a9442d5fda3c43dc0)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "strrev", [str]))

    @jsii.member(jsii_name="substr")
    @builtins.classmethod
    def substr(
        cls,
        str: builtins.str,
        offset: jsii.Number,
        length: jsii.Number,
    ) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/substr substr} extracts a substring from a given string by offset and (maximum) length.

        :param str: -
        :param offset: -
        :param length: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7f0fe7553eee1d90b146664a7052e1a686ef5731413210cee080e71c2bcde496)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
            check_type(argname="argument offset", value=offset, expected_type=type_hints["offset"])
            check_type(argname="argument length", value=length, expected_type=type_hints["length"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "substr", [str, offset, length]))

    @jsii.member(jsii_name="sum")
    @builtins.classmethod
    def sum(cls, list: typing.Any) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/sum sum} takes a list or set of numbers and returns the sum of those numbers.

        :param list: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__578d03977d89d801eb6b00c2d8304a5f264fc7727519260dabc97955ef84e1f0)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "sum", [list]))

    @jsii.member(jsii_name="templatefile")
    @builtins.classmethod
    def templatefile(cls, path: builtins.str, vars: typing.Any) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/templatefile templatefile} reads the file at the given path and renders its content as a template using a supplied set of template variables.

        :param path: -
        :param vars: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c76b176034dbe10e31045d672834717ca0501daadbbace2b4c5ffa844d08d177)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
            check_type(argname="argument vars", value=vars, expected_type=type_hints["vars"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "templatefile", [path, vars]))

    @jsii.member(jsii_name="textdecodebase64")
    @builtins.classmethod
    def textdecodebase64(
        cls,
        source: builtins.str,
        encoding: builtins.str,
    ) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/textdecodebase64 textdecodebase64} function decodes a string that was previously Base64-encoded, and then interprets the result as characters in a specified character encoding.

        :param source: -
        :param encoding: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__28abf90d76672e97155cf5ff248550579a78c71ff3d4cee1fbca4198f4defc7a)
            check_type(argname="argument source", value=source, expected_type=type_hints["source"])
            check_type(argname="argument encoding", value=encoding, expected_type=type_hints["encoding"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "textdecodebase64", [source, encoding]))

    @jsii.member(jsii_name="textencodebase64")
    @builtins.classmethod
    def textencodebase64(
        cls,
        str: builtins.str,
        encoding: builtins.str,
    ) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/textencodebase64 textencodebase64} encodes the unicode characters in a given string using a specified character encoding, returning the result base64 encoded because Terraform language strings are always sequences of unicode characters.

        :param str: -
        :param encoding: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__22173035a105d969e70a07d46d4d53bf825d977a0035c1441b37ad5e2fba26de)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
            check_type(argname="argument encoding", value=encoding, expected_type=type_hints["encoding"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "textencodebase64", [str, encoding]))

    @jsii.member(jsii_name="timeadd")
    @builtins.classmethod
    def timeadd(cls, timestamp: builtins.str, duration: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/timeadd timeadd} adds a duration to a timestamp, returning a new timestamp.

        :param timestamp: -
        :param duration: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__60c2f89197ef63a964f7f4e82ba947f1f019c6247ddfc0b3d87ea2c0c3f656cf)
            check_type(argname="argument timestamp", value=timestamp, expected_type=type_hints["timestamp"])
            check_type(argname="argument duration", value=duration, expected_type=type_hints["duration"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "timeadd", [timestamp, duration]))

    @jsii.member(jsii_name="timecmp")
    @builtins.classmethod
    def timecmp(
        cls,
        timestamp_a: builtins.str,
        timestamp_b: builtins.str,
    ) -> jsii.Number:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/timecmp timecmp} compares two timestamps and returns a number that represents the ordering of the instants those timestamps represent.

        :param timestamp_a: -
        :param timestamp_b: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5cea677b404ba8e9412f285c10e53a1592e03f76583f42217a4f02e99b179b96)
            check_type(argname="argument timestamp_a", value=timestamp_a, expected_type=type_hints["timestamp_a"])
            check_type(argname="argument timestamp_b", value=timestamp_b, expected_type=type_hints["timestamp_b"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "timecmp", [timestamp_a, timestamp_b]))

    @jsii.member(jsii_name="timestamp")
    @builtins.classmethod
    def timestamp(cls) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/timestamp timestamp} returns a UTC timestamp string in `RFC 3339 <https://tools.ietf.org/html/rfc3339>`_ format.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sinvoke(cls, "timestamp", []))

    @jsii.member(jsii_name="title")
    @builtins.classmethod
    def title(cls, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/title title} converts the first letter of each word in the given string to uppercase.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__66bd76bd5c300a0255a5a552e7c18113d6bef4250280788754bf1aa3dac58dbe)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "title", [str]))

    @jsii.member(jsii_name="tobool")
    @builtins.classmethod
    def tobool(cls, v: typing.Any) -> "IResolvable":
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/tobool tobool} converts its argument to a boolean value.

        :param v: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__af6b9742f4403945bc453d4ec774ec5a4b9f5d53ffe858c7b88f11ccaae51e72)
            check_type(argname="argument v", value=v, expected_type=type_hints["v"])
        return typing.cast("IResolvable", jsii.sinvoke(cls, "tobool", [v]))

    @jsii.member(jsii_name="tolist")
    @builtins.classmethod
    def tolist(cls, v: typing.Any) -> typing.List[builtins.str]:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/tolist tolist} converts its argument to a list value.

        :param v: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aa8b4a57bcd7143102adc630590a92c4f0e1a1b8eda4145158d49fc26bc4e610)
            check_type(argname="argument v", value=v, expected_type=type_hints["v"])
        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "tolist", [v]))

    @jsii.member(jsii_name="tomap")
    @builtins.classmethod
    def tomap(cls, v: typing.Any) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/tomap tomap} converts its argument to a map value.

        :param v: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bd0d67bafe08c9d6a38f74c18c9f2cf3c719ef138e159cf30efe1b66f03dc367)
            check_type(argname="argument v", value=v, expected_type=type_hints["v"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "tomap", [v]))

    @jsii.member(jsii_name="tonumber")
    @builtins.classmethod
    def tonumber(cls, v: typing.Any) -> jsii.Number:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/tonumber tonumber} converts its argument to a number value.

        :param v: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e8d252bb074e93a0c98e75eded6408f6e10c18555cf591aa8acb7ae5787d818c)
            check_type(argname="argument v", value=v, expected_type=type_hints["v"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "tonumber", [v]))

    @jsii.member(jsii_name="toset")
    @builtins.classmethod
    def toset(cls, v: typing.Any) -> typing.List[builtins.str]:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/toset toset} converts its argument to a set value.

        :param v: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2e43cf8f2cd5811b47d41854740d07ec75cf3cfb647aab349a0e94ec0f8fee74)
            check_type(argname="argument v", value=v, expected_type=type_hints["v"])
        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "toset", [v]))

    @jsii.member(jsii_name="tostring")
    @builtins.classmethod
    def tostring(cls, v: typing.Any) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/tostring tostring} converts its argument to a string value.

        :param v: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f7563a1cfb6f5d7950d7e696eb3ecb049e3bce4b81e098bb90a50c2f45dee096)
            check_type(argname="argument v", value=v, expected_type=type_hints["v"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "tostring", [v]))

    @jsii.member(jsii_name="transpose")
    @builtins.classmethod
    def transpose(cls, values: typing.Any) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/transpose transpose} takes a map of lists of strings and swaps the keys and values to produce a new map of lists of strings.

        :param values: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3a129153461637c6ac54a32c2a34b3157c1181b7b81769d02d7f2e443f29d5f5)
            check_type(argname="argument values", value=values, expected_type=type_hints["values"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "transpose", [values]))

    @jsii.member(jsii_name="trim")
    @builtins.classmethod
    def trim(cls, str: builtins.str, cutset: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/trim trim} removes the specified set of characters from the start and end of the given string.

        :param str: -
        :param cutset: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__01bafdb8aeae0e1649a538c07a9caa401f1e30198bd3865b496dd6774651f9bc)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
            check_type(argname="argument cutset", value=cutset, expected_type=type_hints["cutset"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "trim", [str, cutset]))

    @jsii.member(jsii_name="trimprefix")
    @builtins.classmethod
    def trimprefix(cls, str: builtins.str, prefix: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/trimprefix trimprefix} removes the specified prefix from the start of the given string. If the string does not start with the prefix, the string is returned unchanged.

        :param str: -
        :param prefix: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__31453e7e37c7397c13afcbf7156bdf9e8c47edcd43536790e622788294192f57)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "trimprefix", [str, prefix]))

    @jsii.member(jsii_name="trimspace")
    @builtins.classmethod
    def trimspace(cls, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/trimspace trimspace} removes any space characters from the start and end of the given string.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f0c741bb85317f2888e76fc421c6a9a5fb7f9677091a6842c6a73801812fccec)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "trimspace", [str]))

    @jsii.member(jsii_name="trimsuffix")
    @builtins.classmethod
    def trimsuffix(cls, str: builtins.str, suffix: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/trimsuffix trimsuffix} removes the specified suffix from the end of the given string.

        :param str: -
        :param suffix: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2eb9c9280c6ad733df509ec2a50abd50b04ff919d54f6585d40fbce1ec5c677a)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
            check_type(argname="argument suffix", value=suffix, expected_type=type_hints["suffix"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "trimsuffix", [str, suffix]))

    @jsii.member(jsii_name="try")
    @builtins.classmethod
    def try_(cls, expressions: typing.Sequence[typing.Any]) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/try try} evaluates all of its argument expressions in turn and returns the result of the first one that does not produce any errors.

        :param expressions: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b1b0fc999f2a74d44252ee1bc8191ac093000ed90ad242fac8f4fda196c99b90)
            check_type(argname="argument expressions", value=expressions, expected_type=type_hints["expressions"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "try", [expressions]))

    @jsii.member(jsii_name="upper")
    @builtins.classmethod
    def upper(cls, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/upper upper} converts all cased letters in the given string to uppercase.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a495becaa7d3cbffa716e180f8bee1460659c3033764f80f52eaf130d96b254d)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "upper", [str]))

    @jsii.member(jsii_name="urlencode")
    @builtins.classmethod
    def urlencode(cls, str: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/urlencode urlencode} applies URL encoding to a given string.

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__96603d9859fed0128d4493d81b13e961e14f9f91fcb0c8d4d2200bd7c56e1bdd)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "urlencode", [str]))

    @jsii.member(jsii_name="uuid")
    @builtins.classmethod
    def uuid(cls) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/uuid uuid} generates a unique identifier string.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sinvoke(cls, "uuid", []))

    @jsii.member(jsii_name="uuidv5")
    @builtins.classmethod
    def uuidv5(cls, namespace: builtins.str, name: builtins.str) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/uuidv5 uuidv5} generates a *name-based* UUID, as described in `RFC 4122 section 4.3 <https://tools.ietf.org/html/rfc4122#section-4.3>`_, also known as a "version 5" UUID.

        :param namespace: -
        :param name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__96253411071bb1f272728a3f979081141c86ac677678a384ac90aefa3b4efb8a)
            check_type(argname="argument namespace", value=namespace, expected_type=type_hints["namespace"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "uuidv5", [namespace, name]))

    @jsii.member(jsii_name="values")
    @builtins.classmethod
    def values(cls, mapping: typing.Any) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/values values} takes a map and returns a list containing the values of the elements in that map.

        :param mapping: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__365b008528a9cb882ccaead2eb8550f2d4c79113cb4da255b503ce7d9b5d3d63)
            check_type(argname="argument mapping", value=mapping, expected_type=type_hints["mapping"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "values", [mapping]))

    @jsii.member(jsii_name="yamldecode")
    @builtins.classmethod
    def yamldecode(cls, src: builtins.str) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/yamldecode yamldecode} parses a string as a subset of YAML, and produces a representation of its value.

        :param src: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9a1cc913fd6f9482396b39d569ef23d16053e917569859ec54422a3b54827f69)
            check_type(argname="argument src", value=src, expected_type=type_hints["src"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "yamldecode", [src]))

    @jsii.member(jsii_name="yamlencode")
    @builtins.classmethod
    def yamlencode(cls, value: typing.Any) -> builtins.str:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/yamlencode yamlencode} encodes a given value to a string using `YAML 1.2 <https://yaml.org/spec/1.2/spec.html>`_ block syntax.

        :param value: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__57d6054065cf9462ecc201f28a1dcd237a59bb628840b2550f1949d18b730081)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "yamlencode", [value]))

    @jsii.member(jsii_name="zipmap")
    @builtins.classmethod
    def zipmap(
        cls,
        keys: typing.Sequence[builtins.str],
        values: typing.Any,
    ) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/functions/zipmap zipmap} constructs a map from a list of keys and a corresponding list of values.

        :param keys: -
        :param values: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bbcc6b00a995ef837f0edbe6c4d470e02ebf769530fb34f9e2ebe9ee8a29d6df)
            check_type(argname="argument keys", value=keys, expected_type=type_hints["keys"])
            check_type(argname="argument values", value=values, expected_type=type_hints["values"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "zipmap", [keys, values]))


@jsii.data_type(
    jsii_type="cdktn.GcsBackendConfig",
    jsii_struct_bases=[],
    name_mapping={
        "bucket": "bucket",
        "access_token": "accessToken",
        "credentials": "credentials",
        "encryption_key": "encryptionKey",
        "impersonate_service_account": "impersonateServiceAccount",
        "impersonate_service_account_delegates": "impersonateServiceAccountDelegates",
        "kms_encryption_key": "kmsEncryptionKey",
        "prefix": "prefix",
        "storeage_custom_endpoint": "storeageCustomEndpoint",
    },
)
class GcsBackendConfig:
    def __init__(
        self,
        *,
        bucket: builtins.str,
        access_token: typing.Optional[builtins.str] = None,
        credentials: typing.Optional[builtins.str] = None,
        encryption_key: typing.Optional[builtins.str] = None,
        impersonate_service_account: typing.Optional[builtins.str] = None,
        impersonate_service_account_delegates: typing.Optional[typing.Sequence[builtins.str]] = None,
        kms_encryption_key: typing.Optional[builtins.str] = None,
        prefix: typing.Optional[builtins.str] = None,
        storeage_custom_endpoint: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Stores the state as an object in a configurable prefix in a pre-existing bucket on Google Cloud Storage (GCS).

        The bucket must exist prior to configuring the backend.

        This backend supports state locking.

        Warning! It is highly recommended that you enable Object Versioning on the GCS bucket
        to allow for state recovery in the case of accidental deletions and human error.

        Read more about this backend in the Terraform docs:
        https://developer.hashicorp.com/terraform/language/settings/backends/gcs

        :param bucket: (experimental) (Required) The name of the GCS bucket. This name must be globally unique.
        :param access_token: (experimental) (Optional) A temporary [OAuth 2.0 access token] obtained from the Google Authorization server, i.e. the Authorization: Bearer token used to authenticate HTTP requests to GCP APIs. This is an alternative to credentials. If both are specified, access_token will be used over the credentials field.
        :param credentials: (experimental) (Optional) Local path to Google Cloud Platform account credentials in JSON format. If unset, Google Application Default Credentials are used. The provided credentials must have Storage Object Admin role on the bucket. Warning: if using the Google Cloud Platform provider as well, it will also pick up the GOOGLE_CREDENTIALS environment variable.
        :param encryption_key: (experimental) (Optional) A 32 byte base64 encoded 'customer supplied encryption key' used to encrypt all state.
        :param impersonate_service_account: (experimental) (Optional) The service account to impersonate for accessing the State Bucket. You must have roles/iam.serviceAccountTokenCreator role on that account for the impersonation to succeed. If you are using a delegation chain, you can specify that using the impersonate_service_account_delegates field. Alternatively, this can be specified using the GOOGLE_IMPERSONATE_SERVICE_ACCOUNT environment variable.
        :param impersonate_service_account_delegates: (experimental) (Optional) The delegation chain for an impersonating a service account.
        :param kms_encryption_key: (experimental) (Optional) A Cloud KMS key ('customer-managed encryption key') used when reading and writing state files in the bucket. Format should be projects/{{project}}/locations/{{location}}/keyRings/{{keyRing}}/cryptoKeys/{{name}}. For more information, including IAM requirements, see {@link https://cloud.google.com/storage/docs/encryption/customer-managed-keys Customer-managed Encryption Keys}.
        :param prefix: (experimental) (Optional) GCS prefix inside the bucket. Named states for workspaces are stored in an object called /.tfstate.
        :param storeage_custom_endpoint: (experimental) (Optional) A URL containing three parts: the protocol, the DNS name pointing to a Private Service Connect endpoint, and the path for the Cloud Storage API (/storage/v1/b). {@link https://developer.hashicorp.com/terraform/language/settings/backends/gcs#storage_custom_endpoint See here for more details}

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__02a007eb5d844cb755597f8f7b398f7a3f7609266be039a95f1a2ef859932394)
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument access_token", value=access_token, expected_type=type_hints["access_token"])
            check_type(argname="argument credentials", value=credentials, expected_type=type_hints["credentials"])
            check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
            check_type(argname="argument impersonate_service_account", value=impersonate_service_account, expected_type=type_hints["impersonate_service_account"])
            check_type(argname="argument impersonate_service_account_delegates", value=impersonate_service_account_delegates, expected_type=type_hints["impersonate_service_account_delegates"])
            check_type(argname="argument kms_encryption_key", value=kms_encryption_key, expected_type=type_hints["kms_encryption_key"])
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
            check_type(argname="argument storeage_custom_endpoint", value=storeage_custom_endpoint, expected_type=type_hints["storeage_custom_endpoint"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bucket": bucket,
        }
        if access_token is not None:
            self._values["access_token"] = access_token
        if credentials is not None:
            self._values["credentials"] = credentials
        if encryption_key is not None:
            self._values["encryption_key"] = encryption_key
        if impersonate_service_account is not None:
            self._values["impersonate_service_account"] = impersonate_service_account
        if impersonate_service_account_delegates is not None:
            self._values["impersonate_service_account_delegates"] = impersonate_service_account_delegates
        if kms_encryption_key is not None:
            self._values["kms_encryption_key"] = kms_encryption_key
        if prefix is not None:
            self._values["prefix"] = prefix
        if storeage_custom_endpoint is not None:
            self._values["storeage_custom_endpoint"] = storeage_custom_endpoint

    @builtins.property
    def bucket(self) -> builtins.str:
        '''(experimental) (Required) The name of the GCS bucket.

        This name must be globally unique.

        :stability: experimental
        '''
        result = self._values.get("bucket")
        assert result is not None, "Required property 'bucket' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def access_token(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A temporary [OAuth 2.0 access token] obtained from the Google Authorization server, i.e. the Authorization: Bearer token used to authenticate HTTP requests to GCP APIs. This is an alternative to credentials. If both are specified, access_token will be used over the credentials field.

        :stability: experimental
        '''
        result = self._values.get("access_token")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def credentials(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Local path to Google Cloud Platform account credentials in JSON format.

        If unset, Google Application Default Credentials are used.
        The provided credentials must have Storage Object Admin role on the bucket.

        Warning: if using the Google Cloud Platform provider as well,
        it will also pick up the GOOGLE_CREDENTIALS environment variable.

        :stability: experimental
        '''
        result = self._values.get("credentials")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def encryption_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A 32 byte base64 encoded 'customer supplied encryption key' used to encrypt all state.

        :stability: experimental
        '''
        result = self._values.get("encryption_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def impersonate_service_account(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The service account to impersonate for accessing the State Bucket.

        You must have roles/iam.serviceAccountTokenCreator role on that account for the impersonation to succeed.
        If you are using a delegation chain, you can specify that using the impersonate_service_account_delegates field.
        Alternatively, this can be specified using the GOOGLE_IMPERSONATE_SERVICE_ACCOUNT environment variable.

        :stability: experimental
        '''
        result = self._values.get("impersonate_service_account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def impersonate_service_account_delegates(
        self,
    ) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) (Optional) The delegation chain for an impersonating a service account.

        :stability: experimental
        '''
        result = self._values.get("impersonate_service_account_delegates")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def kms_encryption_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A Cloud KMS key ('customer-managed encryption key') used when reading and writing state files in the bucket.

        Format should be projects/{{project}}/locations/{{location}}/keyRings/{{keyRing}}/cryptoKeys/{{name}}.
        For more information, including IAM requirements, see {@link https://cloud.google.com/storage/docs/encryption/customer-managed-keys Customer-managed Encryption Keys}.

        :stability: experimental
        '''
        result = self._values.get("kms_encryption_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def prefix(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) GCS prefix inside the bucket.

        Named states for workspaces are stored in an object called /.tfstate.

        :stability: experimental
        '''
        result = self._values.get("prefix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def storeage_custom_endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A URL containing three parts: the protocol, the DNS name pointing to a Private Service Connect endpoint, and the path for the Cloud Storage API (/storage/v1/b).

        {@link https://developer.hashicorp.com/terraform/language/settings/backends/gcs#storage_custom_endpoint See here for more details}

        :stability: experimental
        '''
        result = self._values.get("storeage_custom_endpoint")
        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 "GcsBackendConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.HttpBackendConfig",
    jsii_struct_bases=[],
    name_mapping={
        "address": "address",
        "client_ca_certificate_pem": "clientCaCertificatePem",
        "client_certificate_pem": "clientCertificatePem",
        "client_private_key_pem": "clientPrivateKeyPem",
        "lock_address": "lockAddress",
        "lock_method": "lockMethod",
        "password": "password",
        "retry_max": "retryMax",
        "retry_wait_max": "retryWaitMax",
        "retry_wait_min": "retryWaitMin",
        "skip_cert_verification": "skipCertVerification",
        "unlock_address": "unlockAddress",
        "unlock_method": "unlockMethod",
        "update_method": "updateMethod",
        "username": "username",
    },
)
class HttpBackendConfig:
    def __init__(
        self,
        *,
        address: builtins.str,
        client_ca_certificate_pem: typing.Optional[builtins.str] = None,
        client_certificate_pem: typing.Optional[builtins.str] = None,
        client_private_key_pem: typing.Optional[builtins.str] = None,
        lock_address: typing.Optional[builtins.str] = None,
        lock_method: typing.Optional[builtins.str] = None,
        password: typing.Optional[builtins.str] = None,
        retry_max: typing.Optional[jsii.Number] = None,
        retry_wait_max: typing.Optional[jsii.Number] = None,
        retry_wait_min: typing.Optional[jsii.Number] = None,
        skip_cert_verification: typing.Optional[builtins.bool] = None,
        unlock_address: typing.Optional[builtins.str] = None,
        unlock_method: typing.Optional[builtins.str] = None,
        update_method: typing.Optional[builtins.str] = None,
        username: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Stores the state using a simple REST client.

        State will be fetched via GET, updated via POST, and purged with DELETE.
        The method used for updating is configurable.

        This backend optionally supports state locking.
        When locking support is enabled it will use LOCK and UNLOCK requests providing the lock info in the body.
        The endpoint should return a 423: Locked or 409: Conflict with the holding lock info when
        it's already taken, 200: OK for success. Any other status will be considered an error.
        The ID of the holding lock info will be added as a query parameter to state updates requests.

        Read more about this backend in the Terraform docs:
        https://developer.hashicorp.com/terraform/language/settings/backends/http

        :param address: (experimental) (Required) The address of the REST endpoint.
        :param client_ca_certificate_pem: (experimental) (Optional) A PEM-encoded CA certificate chain used by the client to verify server certificates during TLS authentication.
        :param client_certificate_pem: (experimental) (Optional) A PEM-encoded certificate used by the server to verify the client during mutual TLS (mTLS) authentication.
        :param client_private_key_pem: (experimental) (Optional) A PEM-encoded private key, required if client_certificate_pem is specified.
        :param lock_address: (experimental) (Optional) The address of the lock REST endpoint. Defaults to disabled.
        :param lock_method: (experimental) (Optional) The HTTP method to use when locking. Defaults to LOCK.
        :param password: (experimental) (Optional) The password for HTTP basic authentication.
        :param retry_max: (experimental) (Optional) The number of HTTP request retries. Defaults to 2.
        :param retry_wait_max: (experimental) (Optional) The maximum time in seconds to wait between HTTP request attempts. Defaults to 30.
        :param retry_wait_min: (experimental) (Optional) The minimum time in seconds to wait between HTTP request attempts. Defaults to 1.
        :param skip_cert_verification: (experimental) (Optional) Whether to skip TLS verification. Defaults to false.
        :param unlock_address: (experimental) (Optional) The address of the unlock REST endpoint. Defaults to disabled.
        :param unlock_method: (experimental) (Optional) The HTTP method to use when unlocking. Defaults to UNLOCK.
        :param update_method: (experimental) (Optional) HTTP method to use when updating state. Defaults to POST.
        :param username: (experimental) (Optional) The username for HTTP basic authentication.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__27729e4a0abd45031476ee90b812455ae6ea91f9c86638a8632a9d1299e23f8f)
            check_type(argname="argument address", value=address, expected_type=type_hints["address"])
            check_type(argname="argument client_ca_certificate_pem", value=client_ca_certificate_pem, expected_type=type_hints["client_ca_certificate_pem"])
            check_type(argname="argument client_certificate_pem", value=client_certificate_pem, expected_type=type_hints["client_certificate_pem"])
            check_type(argname="argument client_private_key_pem", value=client_private_key_pem, expected_type=type_hints["client_private_key_pem"])
            check_type(argname="argument lock_address", value=lock_address, expected_type=type_hints["lock_address"])
            check_type(argname="argument lock_method", value=lock_method, expected_type=type_hints["lock_method"])
            check_type(argname="argument password", value=password, expected_type=type_hints["password"])
            check_type(argname="argument retry_max", value=retry_max, expected_type=type_hints["retry_max"])
            check_type(argname="argument retry_wait_max", value=retry_wait_max, expected_type=type_hints["retry_wait_max"])
            check_type(argname="argument retry_wait_min", value=retry_wait_min, expected_type=type_hints["retry_wait_min"])
            check_type(argname="argument skip_cert_verification", value=skip_cert_verification, expected_type=type_hints["skip_cert_verification"])
            check_type(argname="argument unlock_address", value=unlock_address, expected_type=type_hints["unlock_address"])
            check_type(argname="argument unlock_method", value=unlock_method, expected_type=type_hints["unlock_method"])
            check_type(argname="argument update_method", value=update_method, expected_type=type_hints["update_method"])
            check_type(argname="argument username", value=username, expected_type=type_hints["username"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "address": address,
        }
        if client_ca_certificate_pem is not None:
            self._values["client_ca_certificate_pem"] = client_ca_certificate_pem
        if client_certificate_pem is not None:
            self._values["client_certificate_pem"] = client_certificate_pem
        if client_private_key_pem is not None:
            self._values["client_private_key_pem"] = client_private_key_pem
        if lock_address is not None:
            self._values["lock_address"] = lock_address
        if lock_method is not None:
            self._values["lock_method"] = lock_method
        if password is not None:
            self._values["password"] = password
        if retry_max is not None:
            self._values["retry_max"] = retry_max
        if retry_wait_max is not None:
            self._values["retry_wait_max"] = retry_wait_max
        if retry_wait_min is not None:
            self._values["retry_wait_min"] = retry_wait_min
        if skip_cert_verification is not None:
            self._values["skip_cert_verification"] = skip_cert_verification
        if unlock_address is not None:
            self._values["unlock_address"] = unlock_address
        if unlock_method is not None:
            self._values["unlock_method"] = unlock_method
        if update_method is not None:
            self._values["update_method"] = update_method
        if username is not None:
            self._values["username"] = username

    @builtins.property
    def address(self) -> builtins.str:
        '''(experimental) (Required) The address of the REST endpoint.

        :stability: experimental
        '''
        result = self._values.get("address")
        assert result is not None, "Required property 'address' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def client_ca_certificate_pem(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A PEM-encoded CA certificate chain used by the client to verify server certificates during TLS authentication.

        :stability: experimental
        '''
        result = self._values.get("client_ca_certificate_pem")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def client_certificate_pem(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A PEM-encoded certificate used by the server to verify the client during mutual TLS (mTLS) authentication.

        :stability: experimental
        '''
        result = self._values.get("client_certificate_pem")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def client_private_key_pem(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A PEM-encoded private key, required if client_certificate_pem is specified.

        :stability: experimental
        '''
        result = self._values.get("client_private_key_pem")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def lock_address(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The address of the lock REST endpoint.

        Defaults to disabled.

        :stability: experimental
        '''
        result = self._values.get("lock_address")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def lock_method(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The HTTP method to use when locking.

        Defaults to LOCK.

        :stability: experimental
        '''
        result = self._values.get("lock_method")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def password(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The password for HTTP basic authentication.

        :stability: experimental
        '''
        result = self._values.get("password")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def retry_max(self) -> typing.Optional[jsii.Number]:
        '''(experimental) (Optional) The number of HTTP request retries.

        Defaults to 2.

        :stability: experimental
        '''
        result = self._values.get("retry_max")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def retry_wait_max(self) -> typing.Optional[jsii.Number]:
        '''(experimental) (Optional) The maximum time in seconds to wait between HTTP request attempts.

        Defaults to 30.

        :stability: experimental
        '''
        result = self._values.get("retry_wait_max")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def retry_wait_min(self) -> typing.Optional[jsii.Number]:
        '''(experimental) (Optional) The minimum time in seconds to wait between HTTP request attempts.

        Defaults to 1.

        :stability: experimental
        '''
        result = self._values.get("retry_wait_min")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def skip_cert_verification(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Whether to skip TLS verification.

        Defaults to false.

        :stability: experimental
        '''
        result = self._values.get("skip_cert_verification")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def unlock_address(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The address of the unlock REST endpoint.

        Defaults to disabled.

        :stability: experimental
        '''
        result = self._values.get("unlock_address")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def unlock_method(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The HTTP method to use when unlocking.

        Defaults to UNLOCK.

        :stability: experimental
        '''
        result = self._values.get("unlock_method")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def update_method(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) HTTP method to use when updating state.

        Defaults to POST.

        :stability: experimental
        '''
        result = self._values.get("update_method")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def username(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The username for HTTP basic authentication.

        :stability: experimental
        '''
        result = self._values.get("username")
        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 "HttpBackendConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.interface(jsii_type="cdktn.IAnyProducer")
class IAnyProducer(typing_extensions.Protocol):
    '''(experimental) Interface for lazy untyped value producers.

    :stability: experimental
    '''

    @jsii.member(jsii_name="produce")
    def produce(self, context: "IResolveContext") -> typing.Any:
        '''(experimental) Produce the value.

        :param context: -

        :stability: experimental
        '''
        ...


class _IAnyProducerProxy:
    '''(experimental) Interface for lazy untyped value producers.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.IAnyProducer"

    @jsii.member(jsii_name="produce")
    def produce(self, context: "IResolveContext") -> typing.Any:
        '''(experimental) Produce the value.

        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4a0159196c8851281f3a72f27e861c856b6edfa3fd9095efa5c3f4c1b630ae0e)
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast(typing.Any, jsii.invoke(self, "produce", [context]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IAnyProducer).__jsii_proxy_class__ = lambda : _IAnyProducerProxy


@jsii.interface(jsii_type="cdktn.IAspect")
class IAspect(typing_extensions.Protocol):
    '''(experimental) Represents an Aspect.

    :stability: experimental
    '''

    @jsii.member(jsii_name="visit")
    def visit(self, node: _constructs_77d1e7e8.IConstruct) -> None:
        '''(experimental) All aspects can visit an IConstruct.

        :param node: -

        :stability: experimental
        '''
        ...


class _IAspectProxy:
    '''(experimental) Represents an Aspect.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.IAspect"

    @jsii.member(jsii_name="visit")
    def visit(self, node: _constructs_77d1e7e8.IConstruct) -> None:
        '''(experimental) All aspects can visit an IConstruct.

        :param node: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__48fc437143c216b0e0b12970decc48ef59cf9c66c38c3b9962300ce64173a576)
            check_type(argname="argument node", value=node, expected_type=type_hints["node"])
        return typing.cast(None, jsii.invoke(self, "visit", [node]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IAspect).__jsii_proxy_class__ = lambda : _IAspectProxy


@jsii.interface(jsii_type="cdktn.IFragmentConcatenator")
class IFragmentConcatenator(typing_extensions.Protocol):
    '''(experimental) Function used to concatenate symbols in the target document language.

    Interface so it could potentially be exposed over jsii.

    :stability: experimental
    '''

    @jsii.member(jsii_name="join")
    def join(self, left: typing.Any, right: typing.Any) -> typing.Any:
        '''(experimental) Join the fragment on the left and on the right.

        :param left: -
        :param right: -

        :stability: experimental
        '''
        ...


class _IFragmentConcatenatorProxy:
    '''(experimental) Function used to concatenate symbols in the target document language.

    Interface so it could potentially be exposed over jsii.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.IFragmentConcatenator"

    @jsii.member(jsii_name="join")
    def join(self, left: typing.Any, right: typing.Any) -> typing.Any:
        '''(experimental) Join the fragment on the left and on the right.

        :param left: -
        :param right: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0524e3980277b204376778b01f8296df52f017fa2aa7cac9d5ee6ccc7e021fd1)
            check_type(argname="argument left", value=left, expected_type=type_hints["left"])
            check_type(argname="argument right", value=right, expected_type=type_hints["right"])
        return typing.cast(typing.Any, jsii.invoke(self, "join", [left, right]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IFragmentConcatenator).__jsii_proxy_class__ = lambda : _IFragmentConcatenatorProxy


@jsii.interface(jsii_type="cdktn.IImportableConfig")
class IImportableConfig(typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    @builtins.property
    @jsii.member(jsii_name="importId")
    def import_id(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        ...

    @import_id.setter
    def import_id(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="terraformResourceType")
    def terraform_resource_type(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        ...

    @terraform_resource_type.setter
    def terraform_resource_type(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="provider")
    def provider(self) -> typing.Optional["TerraformProvider"]:
        '''
        :stability: experimental
        '''
        ...

    @provider.setter
    def provider(self, value: typing.Optional["TerraformProvider"]) -> None:
        ...


class _IImportableConfigProxy:
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.IImportableConfig"

    @builtins.property
    @jsii.member(jsii_name="importId")
    def import_id(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "importId"))

    @import_id.setter
    def import_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8d957f71f0265de177ea5450b3a0984b75c52194949c5fabb08675bc988ef457)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "importId", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResourceType")
    def terraform_resource_type(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformResourceType"))

    @terraform_resource_type.setter
    def terraform_resource_type(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e52cbf39cd18f178786e0f49cbec882952a745c847453b1716ffbc6c79d90420)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResourceType", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="provider")
    def provider(self) -> typing.Optional["TerraformProvider"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional["TerraformProvider"], jsii.get(self, "provider"))

    @provider.setter
    def provider(self, value: typing.Optional["TerraformProvider"]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__95ec7c9877f9d693fda9f27623c78055503ed51d9c56aa428aeb9dbffaac1d24)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "provider", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IImportableConfig).__jsii_proxy_class__ = lambda : _IImportableConfigProxy


@jsii.interface(jsii_type="cdktn.IInterpolatingParent")
class IInterpolatingParent(typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    @jsii.member(jsii_name="interpolationForAttribute")
    def interpolation_for_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> "IResolvable":
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        ...


class _IInterpolatingParentProxy:
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.IInterpolatingParent"

    @jsii.member(jsii_name="interpolationForAttribute")
    def interpolation_for_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> "IResolvable":
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e754eb4c8f0f209613ac7c4daeeef410ba96668d872b500a8d0663e6a9029850)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast("IResolvable", jsii.invoke(self, "interpolationForAttribute", [terraform_attribute]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IInterpolatingParent).__jsii_proxy_class__ = lambda : _IInterpolatingParentProxy


@jsii.interface(jsii_type="cdktn.IListProducer")
class IListProducer(typing_extensions.Protocol):
    '''(experimental) Interface for lazy list producers.

    :stability: experimental
    '''

    @jsii.member(jsii_name="produce")
    def produce(
        self,
        context: "IResolveContext",
    ) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) Produce the list value.

        :param context: -

        :stability: experimental
        '''
        ...


class _IListProducerProxy:
    '''(experimental) Interface for lazy list producers.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.IListProducer"

    @jsii.member(jsii_name="produce")
    def produce(
        self,
        context: "IResolveContext",
    ) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) Produce the list value.

        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__edc2bbaa50791d52a25063eb84845c7f5999fb858ed25087ddec25b6d102379d)
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.invoke(self, "produce", [context]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IListProducer).__jsii_proxy_class__ = lambda : _IListProducerProxy


@jsii.interface(jsii_type="cdktn.IManifest")
class IManifest(typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    @builtins.property
    @jsii.member(jsii_name="stacks")
    def stacks(self) -> typing.Mapping[builtins.str, "StackManifest"]:
        '''
        :stability: experimental
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="version")
    def version(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        ...


class _IManifestProxy:
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.IManifest"

    @builtins.property
    @jsii.member(jsii_name="stacks")
    def stacks(self) -> typing.Mapping[builtins.str, "StackManifest"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, "StackManifest"], jsii.get(self, "stacks"))

    @builtins.property
    @jsii.member(jsii_name="version")
    def version(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "version"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IManifest).__jsii_proxy_class__ = lambda : _IManifestProxy


@jsii.interface(jsii_type="cdktn.INumberProducer")
class INumberProducer(typing_extensions.Protocol):
    '''(experimental) Interface for lazy number producers.

    :stability: experimental
    '''

    @jsii.member(jsii_name="produce")
    def produce(self, context: "IResolveContext") -> typing.Optional[jsii.Number]:
        '''(experimental) Produce the number value.

        :param context: -

        :stability: experimental
        '''
        ...


class _INumberProducerProxy:
    '''(experimental) Interface for lazy number producers.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.INumberProducer"

    @jsii.member(jsii_name="produce")
    def produce(self, context: "IResolveContext") -> typing.Optional[jsii.Number]:
        '''(experimental) Produce the number value.

        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__040fbbe6cd0b7cfbe51648e9927449cc679660cc7334a61c040885300504af53)
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast(typing.Optional[jsii.Number], jsii.invoke(self, "produce", [context]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, INumberProducer).__jsii_proxy_class__ = lambda : _INumberProducerProxy


@jsii.interface(jsii_type="cdktn.IPostProcessor")
class IPostProcessor(typing_extensions.Protocol):
    '''(experimental) A Token that can post-process the complete resolved value, after resolve() has recursed over it.

    :stability: experimental
    '''

    @jsii.member(jsii_name="postProcess")
    def post_process(self, input: typing.Any, context: "IResolveContext") -> typing.Any:
        '''(experimental) Process the completely resolved value, after full recursion/resolution has happened.

        :param input: -
        :param context: -

        :stability: experimental
        '''
        ...


class _IPostProcessorProxy:
    '''(experimental) A Token that can post-process the complete resolved value, after resolve() has recursed over it.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.IPostProcessor"

    @jsii.member(jsii_name="postProcess")
    def post_process(self, input: typing.Any, context: "IResolveContext") -> typing.Any:
        '''(experimental) Process the completely resolved value, after full recursion/resolution has happened.

        :param input: -
        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3fc42f67c6b31440605d9f916eb60e940d0723e624db6dd5ce92e30e2a945c69)
            check_type(argname="argument input", value=input, expected_type=type_hints["input"])
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast(typing.Any, jsii.invoke(self, "postProcess", [input, context]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IPostProcessor).__jsii_proxy_class__ = lambda : _IPostProcessorProxy


@jsii.interface(jsii_type="cdktn.IRemoteWorkspace")
class IRemoteWorkspace(typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    pass


class _IRemoteWorkspaceProxy:
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.IRemoteWorkspace"
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IRemoteWorkspace).__jsii_proxy_class__ = lambda : _IRemoteWorkspaceProxy


@jsii.interface(jsii_type="cdktn.IResolvable")
class IResolvable(typing_extensions.Protocol):
    '''(experimental) Interface for values that can be resolvable later.

    Tokens are special objects that participate in synthesis.

    :stability: experimental
    '''

    @builtins.property
    @jsii.member(jsii_name="creationStack")
    def creation_stack(self) -> typing.List[builtins.str]:
        '''(experimental) The creation stack of this resolvable which will be appended to errors thrown during resolution.

        If this returns an empty array the stack will not be attached.

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="resolve")
    def resolve(self, context: "IResolveContext") -> typing.Any:
        '''(experimental) Produce the Token's value at resolution time.

        :param context: -

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''(experimental) Return a string representation of this resolvable object.

        Returns a reversible string representation.

        :stability: experimental
        '''
        ...


class _IResolvableProxy:
    '''(experimental) Interface for values that can be resolvable later.

    Tokens are special objects that participate in synthesis.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.IResolvable"

    @builtins.property
    @jsii.member(jsii_name="creationStack")
    def creation_stack(self) -> typing.List[builtins.str]:
        '''(experimental) The creation stack of this resolvable which will be appended to errors thrown during resolution.

        If this returns an empty array the stack will not be attached.

        :stability: experimental
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "creationStack"))

    @jsii.member(jsii_name="resolve")
    def resolve(self, context: "IResolveContext") -> typing.Any:
        '''(experimental) Produce the Token's value at resolution time.

        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6a79ef13a5b5036324b5f0638eb1c8d081b851b71d41cdf54e067d400f7ac2c2)
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolve", [context]))

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''(experimental) Return a string representation of this resolvable object.

        Returns a reversible string representation.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IResolvable).__jsii_proxy_class__ = lambda : _IResolvableProxy


@jsii.interface(jsii_type="cdktn.IResolveContext")
class IResolveContext(typing_extensions.Protocol):
    '''(experimental) Current resolution context for tokens.

    :stability: experimental
    '''

    @builtins.property
    @jsii.member(jsii_name="preparing")
    def preparing(self) -> builtins.bool:
        '''(experimental) True when we are still preparing, false if we're rendering the final output.

        :stability: experimental
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="scope")
    def scope(self) -> _constructs_77d1e7e8.IConstruct:
        '''(experimental) The scope from which resolution has been initiated.

        :stability: experimental
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="ignoreEscapes")
    def ignore_escapes(self) -> typing.Optional[builtins.bool]:
        '''(experimental) True when ${} should not be parsed, and treated as literals.

        :stability: experimental
        '''
        ...

    @ignore_escapes.setter
    def ignore_escapes(self, value: typing.Optional[builtins.bool]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="iteratorContext")
    def iterator_context(self) -> typing.Optional[builtins.str]:
        '''(experimental) TerraformIterators can be passed for block attributes and normal list attributes both require different handling when the iterable variable is accessed e.g. a dynamic block needs each.key while a for expression just needs key.

        :stability: experimental
        '''
        ...

    @iterator_context.setter
    def iterator_context(self, value: typing.Optional[builtins.str]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="suppressBraces")
    def suppress_braces(self) -> typing.Optional[builtins.bool]:
        '''(experimental) True when ${} should be ommitted (because already inside them), false otherwise.

        :stability: experimental
        '''
        ...

    @suppress_braces.setter
    def suppress_braces(self, value: typing.Optional[builtins.bool]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="warnEscapes")
    def warn_escapes(self) -> typing.Optional[builtins.bool]:
        '''(experimental) True when ${} should not be included in the string to be resolved, outputs a warning.

        Default: false

        :stability: experimental
        '''
        ...

    @warn_escapes.setter
    def warn_escapes(self, value: typing.Optional[builtins.bool]) -> None:
        ...

    @jsii.member(jsii_name="registerPostProcessor")
    def register_post_processor(self, post_processor: IPostProcessor) -> None:
        '''(experimental) Use this postprocessor after the entire token structure has been resolved.

        :param post_processor: -

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="resolve")
    def resolve(self, x: typing.Any) -> typing.Any:
        '''(experimental) Resolve an inner object.

        :param x: -

        :stability: experimental
        '''
        ...


class _IResolveContextProxy:
    '''(experimental) Current resolution context for tokens.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.IResolveContext"

    @builtins.property
    @jsii.member(jsii_name="preparing")
    def preparing(self) -> builtins.bool:
        '''(experimental) True when we are still preparing, false if we're rendering the final output.

        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "preparing"))

    @builtins.property
    @jsii.member(jsii_name="scope")
    def scope(self) -> _constructs_77d1e7e8.IConstruct:
        '''(experimental) The scope from which resolution has been initiated.

        :stability: experimental
        '''
        return typing.cast(_constructs_77d1e7e8.IConstruct, jsii.get(self, "scope"))

    @builtins.property
    @jsii.member(jsii_name="ignoreEscapes")
    def ignore_escapes(self) -> typing.Optional[builtins.bool]:
        '''(experimental) True when ${} should not be parsed, and treated as literals.

        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "ignoreEscapes"))

    @ignore_escapes.setter
    def ignore_escapes(self, value: typing.Optional[builtins.bool]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bdd4f993495df4928ff25e2d62d50a0eaf71d254f991494e821acc8847ac7381)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ignoreEscapes", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="iteratorContext")
    def iterator_context(self) -> typing.Optional[builtins.str]:
        '''(experimental) TerraformIterators can be passed for block attributes and normal list attributes both require different handling when the iterable variable is accessed e.g. a dynamic block needs each.key while a for expression just needs key.

        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "iteratorContext"))

    @iterator_context.setter
    def iterator_context(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__224ad1fad2cc9448fafe9c54ba4fcf2d0d30df4dbc92af846f48f04aafb13349)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "iteratorContext", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="suppressBraces")
    def suppress_braces(self) -> typing.Optional[builtins.bool]:
        '''(experimental) True when ${} should be ommitted (because already inside them), false otherwise.

        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "suppressBraces"))

    @suppress_braces.setter
    def suppress_braces(self, value: typing.Optional[builtins.bool]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__57649b2d58965efe4844ab6a3583cfe01431a6274584587137289ce9bb1fff6e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "suppressBraces", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="warnEscapes")
    def warn_escapes(self) -> typing.Optional[builtins.bool]:
        '''(experimental) True when ${} should not be included in the string to be resolved, outputs a warning.

        Default: false

        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "warnEscapes"))

    @warn_escapes.setter
    def warn_escapes(self, value: typing.Optional[builtins.bool]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4e9c13b1984c45331bc843de344702265200444960f35c556580b709623aec48)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "warnEscapes", value) # pyright: ignore[reportArgumentType]

    @jsii.member(jsii_name="registerPostProcessor")
    def register_post_processor(self, post_processor: IPostProcessor) -> None:
        '''(experimental) Use this postprocessor after the entire token structure has been resolved.

        :param post_processor: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__993f9296c0043965e1f85c9ecdb8f793f903ef8df809f312f112270f513ecbce)
            check_type(argname="argument post_processor", value=post_processor, expected_type=type_hints["post_processor"])
        return typing.cast(None, jsii.invoke(self, "registerPostProcessor", [post_processor]))

    @jsii.member(jsii_name="resolve")
    def resolve(self, x: typing.Any) -> typing.Any:
        '''(experimental) Resolve an inner object.

        :param x: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__066083df2ae2796466adee5089cc3f9e46c260e720ca7739b4c01436b9337d84)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolve", [x]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IResolveContext).__jsii_proxy_class__ = lambda : _IResolveContextProxy


@jsii.interface(jsii_type="cdktn.IResource")
class IResource(_constructs_77d1e7e8.IConstruct, typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    @builtins.property
    @jsii.member(jsii_name="stack")
    def stack(self) -> "TerraformStack":
        '''(experimental) The stack in which this resource is defined.

        :stability: experimental
        '''
        ...


class _IResourceProxy(
    jsii.proxy_for(_constructs_77d1e7e8.IConstruct), # type: ignore[misc]
):
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.IResource"

    @builtins.property
    @jsii.member(jsii_name="stack")
    def stack(self) -> "TerraformStack":
        '''(experimental) The stack in which this resource is defined.

        :stability: experimental
        '''
        return typing.cast("TerraformStack", jsii.get(self, "stack"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IResource).__jsii_proxy_class__ = lambda : _IResourceProxy


@jsii.interface(jsii_type="cdktn.IResourceConstructor")
class IResourceConstructor(typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    pass


class _IResourceConstructorProxy:
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.IResourceConstructor"
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IResourceConstructor).__jsii_proxy_class__ = lambda : _IResourceConstructorProxy


@jsii.interface(jsii_type="cdktn.IScopeCallback")
class IScopeCallback(typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    pass


class _IScopeCallbackProxy:
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.IScopeCallback"
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IScopeCallback).__jsii_proxy_class__ = lambda : _IScopeCallbackProxy


@jsii.interface(jsii_type="cdktn.IStackSynthesizer")
class IStackSynthesizer(typing_extensions.Protocol):
    '''(experimental) Encodes information how a certain Stack should be deployed inspired by AWS CDK v2 implementation (synth functionality was removed in constructs v10).

    :stability: experimental
    '''

    @jsii.member(jsii_name="synthesize")
    def synthesize(self, session: "ISynthesisSession") -> None:
        '''(experimental) Synthesize the associated stack to the session.

        :param session: -

        :stability: experimental
        '''
        ...


class _IStackSynthesizerProxy:
    '''(experimental) Encodes information how a certain Stack should be deployed inspired by AWS CDK v2 implementation (synth functionality was removed in constructs v10).

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.IStackSynthesizer"

    @jsii.member(jsii_name="synthesize")
    def synthesize(self, session: "ISynthesisSession") -> None:
        '''(experimental) Synthesize the associated stack to the session.

        :param session: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cd901f3fac7761cfe229a9a81dc57cb71f9ec36ce72d192a6975c8842fabaa38)
            check_type(argname="argument session", value=session, expected_type=type_hints["session"])
        return typing.cast(None, jsii.invoke(self, "synthesize", [session]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IStackSynthesizer).__jsii_proxy_class__ = lambda : _IStackSynthesizerProxy


@jsii.interface(jsii_type="cdktn.IStringProducer")
class IStringProducer(typing_extensions.Protocol):
    '''(experimental) Interface for lazy string producers.

    :stability: experimental
    '''

    @jsii.member(jsii_name="produce")
    def produce(self, context: IResolveContext) -> typing.Optional[builtins.str]:
        '''(experimental) Produce the string value.

        :param context: -

        :stability: experimental
        '''
        ...


class _IStringProducerProxy:
    '''(experimental) Interface for lazy string producers.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.IStringProducer"

    @jsii.member(jsii_name="produce")
    def produce(self, context: IResolveContext) -> typing.Optional[builtins.str]:
        '''(experimental) Produce the string value.

        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6106609dc86be8b07a9c4296893563288e0d42e1c5ecd1dfc631d873db928cfc)
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "produce", [context]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IStringProducer).__jsii_proxy_class__ = lambda : _IStringProducerProxy


@jsii.interface(jsii_type="cdktn.ISynthesisSession")
class ISynthesisSession(typing_extensions.Protocol):
    '''(experimental) Represents a single session of synthesis.

    Passed into ``TerraformStack.onSynthesize()`` methods.
    originally from aws/constructs lib v3.3.126 (synth functionality was removed in constructs v10)

    :stability: experimental
    '''

    @builtins.property
    @jsii.member(jsii_name="manifest")
    def manifest(self) -> "Manifest":
        '''
        :stability: experimental
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="outdir")
    def outdir(self) -> builtins.str:
        '''(experimental) The output directory for this synthesis session.

        :stability: experimental
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="skipValidation")
    def skip_validation(self) -> typing.Optional[builtins.bool]:
        '''
        :stability: experimental
        '''
        ...


class _ISynthesisSessionProxy:
    '''(experimental) Represents a single session of synthesis.

    Passed into ``TerraformStack.onSynthesize()`` methods.
    originally from aws/constructs lib v3.3.126 (synth functionality was removed in constructs v10)

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.ISynthesisSession"

    @builtins.property
    @jsii.member(jsii_name="manifest")
    def manifest(self) -> "Manifest":
        '''
        :stability: experimental
        '''
        return typing.cast("Manifest", jsii.get(self, "manifest"))

    @builtins.property
    @jsii.member(jsii_name="outdir")
    def outdir(self) -> builtins.str:
        '''(experimental) The output directory for this synthesis session.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "outdir"))

    @builtins.property
    @jsii.member(jsii_name="skipValidation")
    def skip_validation(self) -> typing.Optional[builtins.bool]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "skipValidation"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ISynthesisSession).__jsii_proxy_class__ = lambda : _ISynthesisSessionProxy


@jsii.interface(jsii_type="cdktn.ITerraformAddressable")
class ITerraformAddressable(typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    @builtins.property
    @jsii.member(jsii_name="fqn")
    def fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        ...


class _ITerraformAddressableProxy:
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.ITerraformAddressable"

    @builtins.property
    @jsii.member(jsii_name="fqn")
    def fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "fqn"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ITerraformAddressable).__jsii_proxy_class__ = lambda : _ITerraformAddressableProxy


@jsii.interface(jsii_type="cdktn.ITerraformDependable")
class ITerraformDependable(ITerraformAddressable, typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    pass


class _ITerraformDependableProxy(
    jsii.proxy_for(ITerraformAddressable), # type: ignore[misc]
):
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.ITerraformDependable"
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ITerraformDependable).__jsii_proxy_class__ = lambda : _ITerraformDependableProxy


@jsii.interface(jsii_type="cdktn.ITerraformIterator")
class ITerraformIterator(typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    pass


class _ITerraformIteratorProxy:
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.ITerraformIterator"
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ITerraformIterator).__jsii_proxy_class__ = lambda : _ITerraformIteratorProxy


@jsii.interface(jsii_type="cdktn.ITerraformResource")
class ITerraformResource(typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    @builtins.property
    @jsii.member(jsii_name="fqn")
    def fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="friendlyUniqueId")
    def friendly_unique_id(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="terraformResourceType")
    def terraform_resource_type(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="count")
    def count(self) -> typing.Optional[typing.Union[jsii.Number, "TerraformCount"]]:
        '''
        :stability: experimental
        '''
        ...

    @count.setter
    def count(
        self,
        value: typing.Optional[typing.Union[jsii.Number, "TerraformCount"]],
    ) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="dependsOn")
    def depends_on(self) -> typing.Optional[typing.List[builtins.str]]:
        '''
        :stability: experimental
        '''
        ...

    @depends_on.setter
    def depends_on(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="forEach")
    def for_each(self) -> typing.Optional[ITerraformIterator]:
        '''
        :stability: experimental
        '''
        ...

    @for_each.setter
    def for_each(self, value: typing.Optional[ITerraformIterator]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="lifecycle")
    def lifecycle(self) -> typing.Optional["TerraformResourceLifecycle"]:
        '''
        :stability: experimental
        '''
        ...

    @lifecycle.setter
    def lifecycle(self, value: typing.Optional["TerraformResourceLifecycle"]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="provider")
    def provider(self) -> typing.Optional["TerraformProvider"]:
        '''
        :stability: experimental
        '''
        ...

    @provider.setter
    def provider(self, value: typing.Optional["TerraformProvider"]) -> None:
        ...

    @jsii.member(jsii_name="interpolationForAttribute")
    def interpolation_for_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> IResolvable:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        ...


class _ITerraformResourceProxy:
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.ITerraformResource"

    @builtins.property
    @jsii.member(jsii_name="fqn")
    def fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "fqn"))

    @builtins.property
    @jsii.member(jsii_name="friendlyUniqueId")
    def friendly_unique_id(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "friendlyUniqueId"))

    @builtins.property
    @jsii.member(jsii_name="terraformResourceType")
    def terraform_resource_type(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformResourceType"))

    @builtins.property
    @jsii.member(jsii_name="count")
    def count(self) -> typing.Optional[typing.Union[jsii.Number, "TerraformCount"]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[jsii.Number, "TerraformCount"]], jsii.get(self, "count"))

    @count.setter
    def count(
        self,
        value: typing.Optional[typing.Union[jsii.Number, "TerraformCount"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1f88c5e74e7a2aec7c6c2e71ceb318f090fcbbbaf994a55d028e400c7f8cf32e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "count", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="dependsOn")
    def depends_on(self) -> typing.Optional[typing.List[builtins.str]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "dependsOn"))

    @depends_on.setter
    def depends_on(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fd3898a06d3445ff371de5e6106379c8a35d564bb652f2db604419a1ff63217f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "dependsOn", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="forEach")
    def for_each(self) -> typing.Optional[ITerraformIterator]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[ITerraformIterator], jsii.get(self, "forEach"))

    @for_each.setter
    def for_each(self, value: typing.Optional[ITerraformIterator]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7af7a11f65f4cb9ffb382849484dfd007dbb7982fec3f92c522618a09cd92068)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "forEach", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="lifecycle")
    def lifecycle(self) -> typing.Optional["TerraformResourceLifecycle"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional["TerraformResourceLifecycle"], jsii.get(self, "lifecycle"))

    @lifecycle.setter
    def lifecycle(self, value: typing.Optional["TerraformResourceLifecycle"]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__449f726c15bdb834959dbb3bdd9d72d14042d3dfdbb8410e4d4e53847de30830)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "lifecycle", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="provider")
    def provider(self) -> typing.Optional["TerraformProvider"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional["TerraformProvider"], jsii.get(self, "provider"))

    @provider.setter
    def provider(self, value: typing.Optional["TerraformProvider"]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9327104b240661670ab7a7ef35952749a791e542d12541bfb9ea693c6ec3431d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "provider", value) # pyright: ignore[reportArgumentType]

    @jsii.member(jsii_name="interpolationForAttribute")
    def interpolation_for_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> IResolvable:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9285cee271f90cc9b266fc6f12b5d6cbb32538053600c7dfd52244a9bb2b0c84)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(IResolvable, jsii.invoke(self, "interpolationForAttribute", [terraform_attribute]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ITerraformResource).__jsii_proxy_class__ = lambda : _ITerraformResourceProxy


@jsii.interface(jsii_type="cdktn.ITokenMapper")
class ITokenMapper(typing_extensions.Protocol):
    '''(experimental) Interface to apply operation to tokens in a string.

    Interface so it can be exported via jsii.

    :stability: experimental
    '''

    @jsii.member(jsii_name="mapToken")
    def map_token(self, t: IResolvable) -> typing.Any:
        '''(experimental) Replace a single token.

        :param t: -

        :stability: experimental
        '''
        ...


class _ITokenMapperProxy:
    '''(experimental) Interface to apply operation to tokens in a string.

    Interface so it can be exported via jsii.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.ITokenMapper"

    @jsii.member(jsii_name="mapToken")
    def map_token(self, t: IResolvable) -> typing.Any:
        '''(experimental) Replace a single token.

        :param t: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dc0625f97a2f3fdf7324333a6e918fafbb8ac6e546aed97e6648ae7207123413)
            check_type(argname="argument t", value=t, expected_type=type_hints["t"])
        return typing.cast(typing.Any, jsii.invoke(self, "mapToken", [t]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ITokenMapper).__jsii_proxy_class__ = lambda : _ITokenMapperProxy


@jsii.interface(jsii_type="cdktn.ITokenResolver")
class ITokenResolver(typing_extensions.Protocol):
    '''(experimental) How to resolve tokens.

    :stability: experimental
    '''

    @jsii.member(jsii_name="resolveList")
    def resolve_list(
        self,
        l: typing.Sequence[builtins.str],
        context: IResolveContext,
    ) -> typing.Any:
        '''(experimental) Resolve a tokenized list.

        :param l: -
        :param context: -

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="resolveMap")
    def resolve_map(
        self,
        m: typing.Mapping[builtins.str, typing.Any],
        context: IResolveContext,
    ) -> typing.Any:
        '''(experimental) Resolve a tokenized map.

        :param m: -
        :param context: -

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="resolveNumberList")
    def resolve_number_list(
        self,
        l: typing.Sequence[jsii.Number],
        context: IResolveContext,
    ) -> typing.Any:
        '''(experimental) Resolve a tokenized number list.

        :param l: -
        :param context: -

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="resolveString")
    def resolve_string(
        self,
        s: "TokenizedStringFragments",
        context: IResolveContext,
    ) -> typing.Any:
        '''(experimental) Resolve a string with at least one stringified token in it.

        (May use concatenation)

        :param s: -
        :param context: -

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="resolveToken")
    def resolve_token(
        self,
        t: IResolvable,
        context: IResolveContext,
        post_processor: IPostProcessor,
    ) -> typing.Any:
        '''(experimental) Resolve a single token.

        :param t: -
        :param context: -
        :param post_processor: -

        :stability: experimental
        '''
        ...


class _ITokenResolverProxy:
    '''(experimental) How to resolve tokens.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdktn.ITokenResolver"

    @jsii.member(jsii_name="resolveList")
    def resolve_list(
        self,
        l: typing.Sequence[builtins.str],
        context: IResolveContext,
    ) -> typing.Any:
        '''(experimental) Resolve a tokenized list.

        :param l: -
        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e5c536b94a6ecf79f0fff22e16888e164f773a472065adb487d585c3bcdf1a50)
            check_type(argname="argument l", value=l, expected_type=type_hints["l"])
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolveList", [l, context]))

    @jsii.member(jsii_name="resolveMap")
    def resolve_map(
        self,
        m: typing.Mapping[builtins.str, typing.Any],
        context: IResolveContext,
    ) -> typing.Any:
        '''(experimental) Resolve a tokenized map.

        :param m: -
        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__77c936c22797fdbb8202d7dafdd309b4415f746374e701c8542f4b108d145b18)
            check_type(argname="argument m", value=m, expected_type=type_hints["m"])
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolveMap", [m, context]))

    @jsii.member(jsii_name="resolveNumberList")
    def resolve_number_list(
        self,
        l: typing.Sequence[jsii.Number],
        context: IResolveContext,
    ) -> typing.Any:
        '''(experimental) Resolve a tokenized number list.

        :param l: -
        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a1060a7520326b72460b776e4a7f0c3ac663ab99601334dd0236182c3ec12b8e)
            check_type(argname="argument l", value=l, expected_type=type_hints["l"])
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolveNumberList", [l, context]))

    @jsii.member(jsii_name="resolveString")
    def resolve_string(
        self,
        s: "TokenizedStringFragments",
        context: IResolveContext,
    ) -> typing.Any:
        '''(experimental) Resolve a string with at least one stringified token in it.

        (May use concatenation)

        :param s: -
        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__71a6271008e6a9d7c10d7bd3fcb94d7d1179cb97ef723d31e047e514bbe35cf9)
            check_type(argname="argument s", value=s, expected_type=type_hints["s"])
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolveString", [s, context]))

    @jsii.member(jsii_name="resolveToken")
    def resolve_token(
        self,
        t: IResolvable,
        context: IResolveContext,
        post_processor: IPostProcessor,
    ) -> typing.Any:
        '''(experimental) Resolve a single token.

        :param t: -
        :param context: -
        :param post_processor: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__446ac9cdf660783f83d823168622856e6e30e8cf8f9d6fd5e284ebabaab43b56)
            check_type(argname="argument t", value=t, expected_type=type_hints["t"])
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
            check_type(argname="argument post_processor", value=post_processor, expected_type=type_hints["post_processor"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolveToken", [t, context, post_processor]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ITokenResolver).__jsii_proxy_class__ = lambda : _ITokenResolverProxy


class Lazy(metaclass=jsii.JSIIMeta, jsii_type="cdktn.Lazy"):
    '''(experimental) Lazily produce a value.

    Can be used to return a string, list or numeric value whose actual value
    will only be calculated later, during synthesis.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="anyValue")
    @builtins.classmethod
    def any_value(
        cls,
        producer: IAnyProducer,
        *,
        display_hint: typing.Optional[builtins.str] = None,
        omit_empty_array: typing.Optional[builtins.bool] = None,
    ) -> IResolvable:
        '''(experimental) Produces a lazy token from an untyped value.

        :param producer: The lazy producer.
        :param display_hint: (experimental) Use the given name as a display hint. Default: - No hint
        :param omit_empty_array: (experimental) If the produced value is an array and it is empty, return 'undefined' instead. Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2fa40fb53d29e55c7fbdf687d5ff05a4cbea41475d41ac17521f5b945e2c8100)
            check_type(argname="argument producer", value=producer, expected_type=type_hints["producer"])
        options = LazyAnyValueOptions(
            display_hint=display_hint, omit_empty_array=omit_empty_array
        )

        return typing.cast(IResolvable, jsii.sinvoke(cls, "anyValue", [producer, options]))

    @jsii.member(jsii_name="listValue")
    @builtins.classmethod
    def list_value(
        cls,
        producer: IListProducer,
        *,
        display_hint: typing.Optional[builtins.str] = None,
        omit_empty: typing.Optional[builtins.bool] = None,
    ) -> typing.List[builtins.str]:
        '''(experimental) Returns a list-ified token for a lazy value.

        :param producer: The producer.
        :param display_hint: (experimental) Use the given name as a display hint. Default: - No hint
        :param omit_empty: (experimental) If the produced list is empty, return 'undefined' instead. Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c1628b41b89cb0fed2f7a962ac64b2ee841aebd1d5b366b83b72e9a8acdb5761)
            check_type(argname="argument producer", value=producer, expected_type=type_hints["producer"])
        options = LazyListValueOptions(
            display_hint=display_hint, omit_empty=omit_empty
        )

        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "listValue", [producer, options]))

    @jsii.member(jsii_name="numberValue")
    @builtins.classmethod
    def number_value(cls, producer: INumberProducer) -> jsii.Number:
        '''(experimental) Returns a numberified token for a lazy value.

        :param producer: The producer.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4f9529a83825302681de0dcf814c2af4992aa88a16eaeb5828a2ebcc8949c1d3)
            check_type(argname="argument producer", value=producer, expected_type=type_hints["producer"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "numberValue", [producer]))

    @jsii.member(jsii_name="stringValue")
    @builtins.classmethod
    def string_value(
        cls,
        producer: IStringProducer,
        *,
        display_hint: typing.Optional[builtins.str] = None,
    ) -> builtins.str:
        '''(experimental) Returns a stringified token for a lazy value.

        :param producer: The producer.
        :param display_hint: (experimental) Use the given name as a display hint. Default: - No hint

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6e8e7689ad601e12458421f1de501fd89035a0de334c0ee8cc69dfcbc20315d5)
            check_type(argname="argument producer", value=producer, expected_type=type_hints["producer"])
        options = LazyStringValueOptions(display_hint=display_hint)

        return typing.cast(builtins.str, jsii.sinvoke(cls, "stringValue", [producer, options]))


@jsii.data_type(
    jsii_type="cdktn.LazyAnyValueOptions",
    jsii_struct_bases=[],
    name_mapping={"display_hint": "displayHint", "omit_empty_array": "omitEmptyArray"},
)
class LazyAnyValueOptions:
    def __init__(
        self,
        *,
        display_hint: typing.Optional[builtins.str] = None,
        omit_empty_array: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''(experimental) Options for creating lazy untyped tokens.

        :param display_hint: (experimental) Use the given name as a display hint. Default: - No hint
        :param omit_empty_array: (experimental) If the produced value is an array and it is empty, return 'undefined' instead. Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__724a09d1f6f0577cb0e49102f3754314c5515a6f688cd9cf37c096ec38c62f02)
            check_type(argname="argument display_hint", value=display_hint, expected_type=type_hints["display_hint"])
            check_type(argname="argument omit_empty_array", value=omit_empty_array, expected_type=type_hints["omit_empty_array"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if display_hint is not None:
            self._values["display_hint"] = display_hint
        if omit_empty_array is not None:
            self._values["omit_empty_array"] = omit_empty_array

    @builtins.property
    def display_hint(self) -> typing.Optional[builtins.str]:
        '''(experimental) Use the given name as a display hint.

        :default: - No hint

        :stability: experimental
        '''
        result = self._values.get("display_hint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def omit_empty_array(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If the produced value is an array and it is empty, return 'undefined' instead.

        :default: false

        :stability: experimental
        '''
        result = self._values.get("omit_empty_array")
        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 "LazyAnyValueOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IResolvable)
class LazyBase(metaclass=jsii.JSIIAbstractClass, jsii_type="cdktn.LazyBase"):
    '''
    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="addPostProcessor")
    def add_post_processor(self, post_processor: IPostProcessor) -> None:
        '''
        :param post_processor: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__14d71377dbabf13e214c9e8b4656bade2b43b4d30282a33022fcb3f0dcc6cc16)
            check_type(argname="argument post_processor", value=post_processor, expected_type=type_hints["post_processor"])
        return typing.cast(None, jsii.invoke(self, "addPostProcessor", [post_processor]))

    @jsii.member(jsii_name="resolve")
    def resolve(self, context: IResolveContext) -> typing.Any:
        '''(experimental) Produce the Token's value at resolution time.

        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__32b3351131ca410b5ced13b0320d80f6e804696a0eaca4b014bd39e950eff76e)
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolve", [context]))

    @jsii.member(jsii_name="resolveLazy")
    @abc.abstractmethod
    def _resolve_lazy(self, context: IResolveContext) -> typing.Any:
        '''
        :param context: -

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="toJSON")
    def to_json(self) -> typing.Any:
        '''(experimental) Turn this Token into JSON.

        Called automatically when JSON.stringify() is called on a Token.

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toJSON", []))

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''(experimental) Return a string representation of this resolvable object.

        Returns a reversible string representation.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @builtins.property
    @jsii.member(jsii_name="creationStack")
    def creation_stack(self) -> typing.List[builtins.str]:
        '''(experimental) The creation stack of this resolvable which will be appended to errors thrown during resolution.

        If this returns an empty array the stack will not be attached.

        :stability: experimental
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "creationStack"))


class _LazyBaseProxy(LazyBase):
    @jsii.member(jsii_name="resolveLazy")
    def _resolve_lazy(self, context: IResolveContext) -> typing.Any:
        '''
        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7af5f701b7ad0b9c3858ed3ec169ccf8859f8bc6637aec85795667a95f742d6d)
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolveLazy", [context]))

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


@jsii.data_type(
    jsii_type="cdktn.LazyListValueOptions",
    jsii_struct_bases=[],
    name_mapping={"display_hint": "displayHint", "omit_empty": "omitEmpty"},
)
class LazyListValueOptions:
    def __init__(
        self,
        *,
        display_hint: typing.Optional[builtins.str] = None,
        omit_empty: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''(experimental) Options for creating a lazy list token.

        :param display_hint: (experimental) Use the given name as a display hint. Default: - No hint
        :param omit_empty: (experimental) If the produced list is empty, return 'undefined' instead. Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__862feef5a838adce4ca3ddb313a3e415d4ce42bd11e0b5bededdb0985828921f)
            check_type(argname="argument display_hint", value=display_hint, expected_type=type_hints["display_hint"])
            check_type(argname="argument omit_empty", value=omit_empty, expected_type=type_hints["omit_empty"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if display_hint is not None:
            self._values["display_hint"] = display_hint
        if omit_empty is not None:
            self._values["omit_empty"] = omit_empty

    @builtins.property
    def display_hint(self) -> typing.Optional[builtins.str]:
        '''(experimental) Use the given name as a display hint.

        :default: - No hint

        :stability: experimental
        '''
        result = self._values.get("display_hint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def omit_empty(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If the produced list is empty, return 'undefined' instead.

        :default: false

        :stability: experimental
        '''
        result = self._values.get("omit_empty")
        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 "LazyListValueOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.LazyStringValueOptions",
    jsii_struct_bases=[],
    name_mapping={"display_hint": "displayHint"},
)
class LazyStringValueOptions:
    def __init__(self, *, display_hint: typing.Optional[builtins.str] = None) -> None:
        '''(experimental) Options for creating a lazy string token.

        :param display_hint: (experimental) Use the given name as a display hint. Default: - No hint

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__13208f60b31bc6f56bf48769a4c49a214b379d88d71e706e749690122cfd0a30)
            check_type(argname="argument display_hint", value=display_hint, expected_type=type_hints["display_hint"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if display_hint is not None:
            self._values["display_hint"] = display_hint

    @builtins.property
    def display_hint(self) -> typing.Optional[builtins.str]:
        '''(experimental) Use the given name as a display hint.

        :default: - No hint

        :stability: experimental
        '''
        result = self._values.get("display_hint")
        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 "LazyStringValueOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.LocalBackendConfig",
    jsii_struct_bases=[],
    name_mapping={"path": "path", "workspace_dir": "workspaceDir"},
)
class LocalBackendConfig:
    def __init__(
        self,
        *,
        path: typing.Optional[builtins.str] = None,
        workspace_dir: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) The local backend stores state on the local filesystem, locks that state using system APIs, and performs operations locally.

        Read more about this backend in the Terraform docs:
        https://developer.hashicorp.com/terraform/language/settings/backends/local

        :param path: (experimental) Path where the state file is stored. Default: - defaults to terraform.${stackId}.tfstate
        :param workspace_dir: (experimental) (Optional) The path to non-default workspaces.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a0560c43ba6a1dbd8ccca9d33d5cee94a0cd48d16c401cfbec0ca24f8a8774ca)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
            check_type(argname="argument workspace_dir", value=workspace_dir, expected_type=type_hints["workspace_dir"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if path is not None:
            self._values["path"] = path
        if workspace_dir is not None:
            self._values["workspace_dir"] = workspace_dir

    @builtins.property
    def path(self) -> typing.Optional[builtins.str]:
        '''(experimental) Path where the state file is stored.

        :default: - defaults to terraform.${stackId}.tfstate

        :stability: experimental
        '''
        result = self._values.get("path")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def workspace_dir(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The path to non-default workspaces.

        :stability: experimental
        '''
        result = self._values.get("workspace_dir")
        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 "LocalBackendConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.LocalExecProvisioner",
    jsii_struct_bases=[],
    name_mapping={
        "command": "command",
        "type": "type",
        "environment": "environment",
        "interpreter": "interpreter",
        "when": "when",
        "working_dir": "workingDir",
    },
)
class LocalExecProvisioner:
    def __init__(
        self,
        *,
        command: builtins.str,
        type: builtins.str,
        environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        interpreter: typing.Optional[typing.Sequence[builtins.str]] = None,
        when: typing.Optional[builtins.str] = None,
        working_dir: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) The local-exec provisioner invokes a local executable after a resource is created.

        This invokes a process on the machine running Terraform, not on the resource.

        See {@link https://developer.hashicorp.com/terraform/language/resources/provisioners/local-exec local-exec}

        :param command: (experimental) This is the command to execute. It can be provided as a relative path to the current working directory or as an absolute path. It is evaluated in a shell, and can use environment variables or Terraform variables.
        :param type: 
        :param environment: (experimental) A record of key value pairs representing the environment of the executed command. It inherits the current process environment.
        :param interpreter: (experimental) If provided, this is a list of interpreter arguments used to execute the command. The first argument is the interpreter itself. It can be provided as a relative path to the current working directory or as an absolute path The remaining arguments are appended prior to the command. This allows building command lines of the form "/bin/bash", "-c", "echo foo". If interpreter is unspecified, sensible defaults will be chosen based on the system OS.
        :param when: (experimental) If provided, specifies when Terraform will execute the command. For example, when = destroy specifies that the provisioner will run when the associated resource is destroyed
        :param working_dir: (experimental) If provided, specifies the working directory where command will be executed. It can be provided as a relative path to the current working directory or as an absolute path. The directory must exist.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__274d7acb56d992610a2be6e73e1b00653a6d50ed77f35e5eb8087bf328e67524)
            check_type(argname="argument command", value=command, expected_type=type_hints["command"])
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
            check_type(argname="argument interpreter", value=interpreter, expected_type=type_hints["interpreter"])
            check_type(argname="argument when", value=when, expected_type=type_hints["when"])
            check_type(argname="argument working_dir", value=working_dir, expected_type=type_hints["working_dir"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "command": command,
            "type": type,
        }
        if environment is not None:
            self._values["environment"] = environment
        if interpreter is not None:
            self._values["interpreter"] = interpreter
        if when is not None:
            self._values["when"] = when
        if working_dir is not None:
            self._values["working_dir"] = working_dir

    @builtins.property
    def command(self) -> builtins.str:
        '''(experimental) This is the command to execute.

        It can be provided as a relative path to the current working directory or as an absolute path.
        It is evaluated in a shell, and can use environment variables or Terraform variables.

        :stability: experimental
        '''
        result = self._values.get("command")
        assert result is not None, "Required property 'command' is missing"
        return typing.cast(builtins.str, result)

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

    @builtins.property
    def environment(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        '''(experimental) A record of key value pairs representing the environment of the executed command.

        It inherits the current process environment.

        :stability: experimental
        '''
        result = self._values.get("environment")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    @builtins.property
    def interpreter(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) If provided, this is a list of interpreter arguments used to execute the command.

        The first argument is the interpreter itself.
        It can be provided as a relative path to the current working directory or as an absolute path
        The remaining arguments are appended prior to the command.
        This allows building command lines of the form "/bin/bash", "-c", "echo foo".
        If interpreter is unspecified, sensible defaults will be chosen based on the system OS.

        :stability: experimental
        '''
        result = self._values.get("interpreter")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def when(self) -> typing.Optional[builtins.str]:
        '''(experimental) If provided, specifies when Terraform will execute the command.

        For example, when = destroy specifies that the provisioner will run when the associated resource is destroyed

        :stability: experimental
        '''
        result = self._values.get("when")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def working_dir(self) -> typing.Optional[builtins.str]:
        '''(experimental) If provided, specifies the working directory where command will be executed.

        It can be provided as a relative path to the current working directory or as an absolute path.
        The directory must exist.

        :stability: experimental
        '''
        result = self._values.get("working_dir")
        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 "LocalExecProvisioner(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IManifest)
class Manifest(metaclass=jsii.JSIIMeta, jsii_type="cdktn.Manifest"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        version: builtins.str,
        outdir: builtins.str,
        hcl_output: builtins.bool,
    ) -> None:
        '''
        :param version: -
        :param outdir: -
        :param hcl_output: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__61f6d0469d8a367e30ba46537674c806255ade18719e532dca077ce226a2595d)
            check_type(argname="argument version", value=version, expected_type=type_hints["version"])
            check_type(argname="argument outdir", value=outdir, expected_type=type_hints["outdir"])
            check_type(argname="argument hcl_output", value=hcl_output, expected_type=type_hints["hcl_output"])
        jsii.create(self.__class__, self, [version, outdir, hcl_output])

    @jsii.member(jsii_name="buildManifest")
    def build_manifest(self) -> IManifest:
        '''
        :stability: experimental
        '''
        return typing.cast(IManifest, jsii.invoke(self, "buildManifest", []))

    @jsii.member(jsii_name="forStack")
    def for_stack(self, stack: "TerraformStack") -> "StackManifest":
        '''
        :param stack: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f43a9c35e0a86216f72804bf74a1bd2b23c9cf31747602192add7a287a17838d)
            check_type(argname="argument stack", value=stack, expected_type=type_hints["stack"])
        return typing.cast("StackManifest", jsii.invoke(self, "forStack", [stack]))

    @jsii.member(jsii_name="writeToFile")
    def write_to_file(self) -> None:
        '''
        :stability: experimental
        '''
        return typing.cast(None, jsii.invoke(self, "writeToFile", []))

    @jsii.python.classproperty
    @jsii.member(jsii_name="fileName")
    def FILE_NAME(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "fileName"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="stackMetadataPath")
    def STACK_METADATA_PATH(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "stackMetadataPath"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="stacksFolder")
    def STACKS_FOLDER(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "stacksFolder"))

    @builtins.property
    @jsii.member(jsii_name="hclOutput")
    def hcl_output(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "hclOutput"))

    @builtins.property
    @jsii.member(jsii_name="outdir")
    def outdir(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "outdir"))

    @builtins.property
    @jsii.member(jsii_name="stackFileName")
    def stack_file_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "stackFileName"))

    @builtins.property
    @jsii.member(jsii_name="stacks")
    def stacks(self) -> typing.Mapping[builtins.str, "StackManifest"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, "StackManifest"], jsii.get(self, "stacks"))

    @builtins.property
    @jsii.member(jsii_name="version")
    def version(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "version"))


@jsii.implements(ITerraformAddressable, IInterpolatingParent, IResolvable)
class MapList(metaclass=jsii.JSIIAbstractClass, jsii_type="cdktn.MapList"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
        wraps_set: builtins.bool,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -
        :param wraps_set: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a44f61bb976c94a555c28732af02f8dd8cf5e34c08cc877f857bf8153fbf84e0)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
            check_type(argname="argument wraps_set", value=wraps_set, expected_type=type_hints["wraps_set"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute, wraps_set])

    @jsii.member(jsii_name="computeFqn")
    def compute_fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "computeFqn", []))

    @jsii.member(jsii_name="interpolationForAttribute")
    def interpolation_for_attribute(self, property: builtins.str) -> IResolvable:
        '''
        :param property: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__514c8a2f9583df6ff076b7057c826442b71efd608481bdf16de75de4eb48feab)
            check_type(argname="argument property", value=property, expected_type=type_hints["property"])
        return typing.cast(IResolvable, jsii.invoke(self, "interpolationForAttribute", [property]))

    @jsii.member(jsii_name="resolve")
    def resolve(self, _context: IResolveContext) -> typing.Any:
        '''(experimental) Produce the Token's value at resolution time.

        :param _context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f1552b80262f33f55bf46b82fc83331effd55432fdcfae4d6fb0348ef40bf0ff)
            check_type(argname="argument _context", value=_context, expected_type=type_hints["_context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolve", [_context]))

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''(experimental) Return a string representation of this resolvable object.

        Returns a reversible string representation.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @builtins.property
    @jsii.member(jsii_name="creationStack")
    def creation_stack(self) -> typing.List[builtins.str]:
        '''(experimental) The creation stack of this resolvable which will be appended to errors thrown during resolution.

        If this returns an empty array the stack will not be attached.

        :stability: experimental
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "creationStack"))

    @builtins.property
    @jsii.member(jsii_name="fqn")
    def fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "fqn"))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a673c456dc2eec78e0bad2e8a3ca1304c045d9a4933e64eb4968cc3a3a5088cb)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__67251ac281cd3c9c48591ad90a1b5d01abd8b0a2f294035ebb9cb79939d0c091)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="wrapsSet")
    def _wraps_set(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "wrapsSet"))

    @_wraps_set.setter
    def _wraps_set(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__53d7e392884d6103e9041687abac691ce226fee1fb7ebc63310618fb9cd437ec)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "wrapsSet", value) # pyright: ignore[reportArgumentType]


class _MapListProxy(MapList):
    pass

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


@jsii.implements(IAspect)
class MigrateIds(metaclass=jsii.JSIIMeta, jsii_type="cdktn.MigrateIds"):
    '''(experimental) For migrating past 0.17 where the feature flag for the old id generation logic was removed after being deprecated since 0.15.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="visit")
    def visit(self, node: _constructs_77d1e7e8.IConstruct) -> None:
        '''(experimental) All aspects can visit an IConstruct.

        :param node: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cb56592fc00188e61a552c37329aaad2d0e77ac93599cd68307a7b3ed441c155)
            check_type(argname="argument node", value=node, expected_type=type_hints["node"])
        return typing.cast(None, jsii.invoke(self, "visit", [node]))


class NamedCloudWorkspace(
    CloudWorkspace,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.NamedCloudWorkspace",
):
    '''(experimental) The name of a single Terraform Cloud workspace.

    You will only be able to use the workspace specified in the configuration with this working directory, and cannot manage workspaces from the CLI (e.g. terraform workspace select or terraform workspace new).

    :stability: experimental
    '''

    def __init__(
        self,
        name: builtins.str,
        project: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param name: -
        :param project: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__846721fcc5c83460a5ea08902a8116748784588fff9a08dbd96962dc3081f9ee)
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument project", value=project, expected_type=type_hints["project"])
        jsii.create(self.__class__, self, [name, project])

    @jsii.member(jsii_name="toHclTerraform")
    def to_hcl_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toHclTerraform", []))

    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toTerraform", []))

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "name"))

    @name.setter
    def name(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b5d40cd84a4eeba066f57f39807be7d8fc12e2ac70b1b97fde678f3a606e5666)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "name", value) # pyright: ignore[reportArgumentType]

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

    @project.setter
    def project(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cdacbeb6ab99146be3200a01d29ab2509ac627c74aa1a04efa77379880d67a05)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "project", value) # pyright: ignore[reportArgumentType]


@jsii.implements(IRemoteWorkspace)
class NamedRemoteWorkspace(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.NamedRemoteWorkspace",
):
    '''
    :stability: experimental
    '''

    def __init__(self, name: builtins.str) -> None:
        '''
        :param name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5e47280287673462fa77e0414a575256383d1fd337f91f5eb402946972e149b6)
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
        jsii.create(self.__class__, self, [name])

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "name"))

    @name.setter
    def name(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6454f2bf12ea2fc5a6975c9e80d0218f875d4d8596eaafff25db3cd4fd86602b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "name", value) # pyright: ignore[reportArgumentType]


@jsii.implements(ITerraformAddressable, IResolvable)
class NumberMap(metaclass=jsii.JSIIMeta, jsii_type="cdktn.NumberMap"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__214c52e45b9070883422d9ab2eed19969eac6baad0f53b505d3f338a8c0f21b5)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute])

    @jsii.member(jsii_name="computeFqn")
    def compute_fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "computeFqn", []))

    @jsii.member(jsii_name="lookup")
    def lookup(self, key: builtins.str) -> jsii.Number:
        '''
        :param key: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aa0df365cd474ab632b497d6c553364b428722dccd9796f22ade40ae3389a640)
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
        return typing.cast(jsii.Number, jsii.invoke(self, "lookup", [key]))

    @jsii.member(jsii_name="resolve")
    def resolve(self, _context: IResolveContext) -> typing.Any:
        '''(experimental) Produce the Token's value at resolution time.

        :param _context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a48edbb8f705597cd1085cd16864d64daee8e41258613abfa5a31fe730552964)
            check_type(argname="argument _context", value=_context, expected_type=type_hints["_context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolve", [_context]))

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''(experimental) Return a string representation of this resolvable object.

        Returns a reversible string representation.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @builtins.property
    @jsii.member(jsii_name="creationStack")
    def creation_stack(self) -> typing.List[builtins.str]:
        '''(experimental) The creation stack of this resolvable which will be appended to errors thrown during resolution.

        If this returns an empty array the stack will not be attached.

        :stability: experimental
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "creationStack"))

    @builtins.property
    @jsii.member(jsii_name="fqn")
    def fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "fqn"))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cee62dfdb022d4055ba597838f76ffd5ab618077b7b9fea900fedb5f61e0335d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__98f5b920e232a14df9946b19e49702229a6f30591827bad88bba73e1b5e89931)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]


class NumberMapList(MapList, metaclass=jsii.JSIIMeta, jsii_type="cdktn.NumberMapList"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
        wraps_set: builtins.bool,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -
        :param wraps_set: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5652f791e9c89cf42150d84ee43d36102e5d321a3bf3f238a94b76b0d9df7d73)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
            check_type(argname="argument wraps_set", value=wraps_set, expected_type=type_hints["wraps_set"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute, wraps_set])

    @jsii.member(jsii_name="get")
    def get(self, index: jsii.Number) -> NumberMap:
        '''
        :param index: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5ebc3bc91d5183eb5087cd625f294385478fbaea207628220638a827157827cd)
            check_type(argname="argument index", value=index, expected_type=type_hints["index"])
        return typing.cast(NumberMap, jsii.invoke(self, "get", [index]))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a015d4a101d96d2f958897a8d16c77947f2a8130dcea57bcc963c57ddb82ac97)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5af1a83a5600895192f5ff912d1975637bf5b650f71b53944020bbe62470163b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="wrapsSet")
    def _wraps_set(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "wrapsSet"))

    @_wraps_set.setter
    def _wraps_set(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2945ad0a64e5aa1fc06c37386342cf289a06aa4bcd3c2819e7510b55430c1924)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "wrapsSet", value) # pyright: ignore[reportArgumentType]


class Op(metaclass=jsii.JSIIMeta, jsii_type="cdktn.Op"):
    '''(experimental) This class contains static functions for all arithmetical and logical operators in the Terraform configuration language.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="add")
    @builtins.classmethod
    def add(cls, left: typing.Any, right: typing.Any) -> jsii.Number:
        '''(experimental) Renders left + right.

        :param left: -
        :param right: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c89edc54c51fd737011d0d1d16c08b61d2d36e8e723f680c851e7f7b5082579c)
            check_type(argname="argument left", value=left, expected_type=type_hints["left"])
            check_type(argname="argument right", value=right, expected_type=type_hints["right"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "add", [left, right]))

    @jsii.member(jsii_name="and")
    @builtins.classmethod
    def and_(cls, left: typing.Any, right: typing.Any) -> IResolvable:
        '''(experimental) Renders left && right.

        :param left: -
        :param right: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__184aa448229db7afe11b1a2eacdadd2a88850fb73e904ee9d3e4a6b97afc13b9)
            check_type(argname="argument left", value=left, expected_type=type_hints["left"])
            check_type(argname="argument right", value=right, expected_type=type_hints["right"])
        return typing.cast(IResolvable, jsii.sinvoke(cls, "and", [left, right]))

    @jsii.member(jsii_name="div")
    @builtins.classmethod
    def div(cls, left: typing.Any, right: typing.Any) -> jsii.Number:
        '''(experimental) Renders left / right.

        :param left: -
        :param right: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8442861840951769d42c33d424f8ac28b3446902528ed56b9aa55bf111e93599)
            check_type(argname="argument left", value=left, expected_type=type_hints["left"])
            check_type(argname="argument right", value=right, expected_type=type_hints["right"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "div", [left, right]))

    @jsii.member(jsii_name="eq")
    @builtins.classmethod
    def eq(cls, left: typing.Any, right: typing.Any) -> IResolvable:
        '''(experimental) Renders left == right.

        :param left: -
        :param right: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a9dd7597581ee2c12f3fc8eeeecab5194b083af2e13a7ef3e335dd7e3b1e2f61)
            check_type(argname="argument left", value=left, expected_type=type_hints["left"])
            check_type(argname="argument right", value=right, expected_type=type_hints["right"])
        return typing.cast(IResolvable, jsii.sinvoke(cls, "eq", [left, right]))

    @jsii.member(jsii_name="gt")
    @builtins.classmethod
    def gt(cls, left: typing.Any, right: typing.Any) -> IResolvable:
        '''(experimental) Renders left > right.

        :param left: -
        :param right: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__62289b2450824c237c7b05d69a5a90899f19717b691a25e8b3b10a335fdf16a5)
            check_type(argname="argument left", value=left, expected_type=type_hints["left"])
            check_type(argname="argument right", value=right, expected_type=type_hints["right"])
        return typing.cast(IResolvable, jsii.sinvoke(cls, "gt", [left, right]))

    @jsii.member(jsii_name="gte")
    @builtins.classmethod
    def gte(cls, left: typing.Any, right: typing.Any) -> IResolvable:
        '''(experimental) Renders left >= right.

        :param left: -
        :param right: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a6c081e3cbad3a06417949424078cdd63771674b9d079ebb3dcb842d2556204b)
            check_type(argname="argument left", value=left, expected_type=type_hints["left"])
            check_type(argname="argument right", value=right, expected_type=type_hints["right"])
        return typing.cast(IResolvable, jsii.sinvoke(cls, "gte", [left, right]))

    @jsii.member(jsii_name="lt")
    @builtins.classmethod
    def lt(cls, left: typing.Any, right: typing.Any) -> IResolvable:
        '''(experimental) Renders left < right.

        :param left: -
        :param right: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__82bb1cd58e2da117736da1c4ab6e18d17e48b076a4fb3644ccfe1b091e99f2db)
            check_type(argname="argument left", value=left, expected_type=type_hints["left"])
            check_type(argname="argument right", value=right, expected_type=type_hints["right"])
        return typing.cast(IResolvable, jsii.sinvoke(cls, "lt", [left, right]))

    @jsii.member(jsii_name="lte")
    @builtins.classmethod
    def lte(cls, left: typing.Any, right: typing.Any) -> IResolvable:
        '''(experimental) Renders left <= right.

        :param left: -
        :param right: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0e09d20865f5c227c4627b6936694ec23b3e2f824d4df94f745ecf38a65338c4)
            check_type(argname="argument left", value=left, expected_type=type_hints["left"])
            check_type(argname="argument right", value=right, expected_type=type_hints["right"])
        return typing.cast(IResolvable, jsii.sinvoke(cls, "lte", [left, right]))

    @jsii.member(jsii_name="mod")
    @builtins.classmethod
    def mod(cls, left: typing.Any, right: typing.Any) -> jsii.Number:
        '''(experimental) Renders left % right.

        :param left: -
        :param right: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fde028c9b08af653c189c5ae2ce62378877da4e30888d67b2433117bfd8c1879)
            check_type(argname="argument left", value=left, expected_type=type_hints["left"])
            check_type(argname="argument right", value=right, expected_type=type_hints["right"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "mod", [left, right]))

    @jsii.member(jsii_name="mul")
    @builtins.classmethod
    def mul(cls, left: typing.Any, right: typing.Any) -> jsii.Number:
        '''(experimental) Renders left * right.

        :param left: -
        :param right: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1000f75d6be97dfeb93725dd0d72d8831e6f765e304c9f3d35a9a8d204b8a88c)
            check_type(argname="argument left", value=left, expected_type=type_hints["left"])
            check_type(argname="argument right", value=right, expected_type=type_hints["right"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "mul", [left, right]))

    @jsii.member(jsii_name="negate")
    @builtins.classmethod
    def negate(cls, expression: typing.Any) -> jsii.Number:
        '''(experimental) Renders -expression.

        :param expression: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6f5fb9218c93366387cdb3196c4011f7811eedc244d46e96bdbe32469b59d6db)
            check_type(argname="argument expression", value=expression, expected_type=type_hints["expression"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "negate", [expression]))

    @jsii.member(jsii_name="neq")
    @builtins.classmethod
    def neq(cls, left: typing.Any, right: typing.Any) -> IResolvable:
        '''(experimental) Renders left != right.

        :param left: -
        :param right: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8dd05cd9ce567fa939232f41d126312b87cfab33709bb65577362099483ed769)
            check_type(argname="argument left", value=left, expected_type=type_hints["left"])
            check_type(argname="argument right", value=right, expected_type=type_hints["right"])
        return typing.cast(IResolvable, jsii.sinvoke(cls, "neq", [left, right]))

    @jsii.member(jsii_name="not")
    @builtins.classmethod
    def not_(cls, expression: typing.Any) -> IResolvable:
        '''(experimental) Renders !expression.

        :param expression: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9250ff5d0d2f42d801de36d35382f5dce7f85e1131f3897d769594ef76f198e4)
            check_type(argname="argument expression", value=expression, expected_type=type_hints["expression"])
        return typing.cast(IResolvable, jsii.sinvoke(cls, "not", [expression]))

    @jsii.member(jsii_name="or")
    @builtins.classmethod
    def or_(cls, left: typing.Any, right: typing.Any) -> IResolvable:
        '''(experimental) Renders left || right.

        :param left: -
        :param right: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__367888dc27094c2253e94bbe0bd3a4b42c9fe599ddd447acfa75591e8ef38e15)
            check_type(argname="argument left", value=left, expected_type=type_hints["left"])
            check_type(argname="argument right", value=right, expected_type=type_hints["right"])
        return typing.cast(IResolvable, jsii.sinvoke(cls, "or", [left, right]))

    @jsii.member(jsii_name="sub")
    @builtins.classmethod
    def sub(cls, left: typing.Any, right: typing.Any) -> jsii.Number:
        '''(experimental) Renders left - right.

        :param left: -
        :param right: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__932d8b82493b130202229f6b4ac14fe2afa8cf77bf5420a78b2ead74aac8e5c1)
            check_type(argname="argument left", value=left, expected_type=type_hints["left"])
            check_type(argname="argument right", value=right, expected_type=type_hints["right"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "sub", [left, right]))


@jsii.data_type(
    jsii_type="cdktn.OssAssumeRole",
    jsii_struct_bases=[],
    name_mapping={
        "role_arn": "roleArn",
        "policy": "policy",
        "session_expiration": "sessionExpiration",
        "session_name": "sessionName",
    },
)
class OssAssumeRole:
    def __init__(
        self,
        *,
        role_arn: builtins.str,
        policy: typing.Optional[builtins.str] = None,
        session_expiration: typing.Optional[jsii.Number] = None,
        session_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param role_arn: 
        :param policy: 
        :param session_expiration: 
        :param session_name: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4ab9e5a718449fadbc8d3a3cf0ff1879e5303ea69fc5de45d97982a12ca61ced)
            check_type(argname="argument role_arn", value=role_arn, expected_type=type_hints["role_arn"])
            check_type(argname="argument policy", value=policy, expected_type=type_hints["policy"])
            check_type(argname="argument session_expiration", value=session_expiration, expected_type=type_hints["session_expiration"])
            check_type(argname="argument session_name", value=session_name, expected_type=type_hints["session_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "role_arn": role_arn,
        }
        if policy is not None:
            self._values["policy"] = policy
        if session_expiration is not None:
            self._values["session_expiration"] = session_expiration
        if session_name is not None:
            self._values["session_name"] = session_name

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

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

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

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


@jsii.data_type(
    jsii_type="cdktn.OssBackendConfig",
    jsii_struct_bases=[],
    name_mapping={
        "bucket": "bucket",
        "access_key": "accessKey",
        "acl": "acl",
        "assume_role": "assumeRole",
        "assume_role_policy": "assumeRolePolicy",
        "assume_role_role_arn": "assumeRoleRoleArn",
        "assume_role_session_expiration": "assumeRoleSessionExpiration",
        "assume_role_session_name": "assumeRoleSessionName",
        "ecs_role_name": "ecsRoleName",
        "encrypt": "encrypt",
        "endpoint": "endpoint",
        "key": "key",
        "prefix": "prefix",
        "profile": "profile",
        "region": "region",
        "secret_key": "secretKey",
        "security_token": "securityToken",
        "shared_credentials_file": "sharedCredentialsFile",
        "sts_endpoint": "stsEndpoint",
        "tablestore_endpoint": "tablestoreEndpoint",
        "tablestore_table": "tablestoreTable",
    },
)
class OssBackendConfig:
    def __init__(
        self,
        *,
        bucket: builtins.str,
        access_key: typing.Optional[builtins.str] = None,
        acl: typing.Optional[builtins.str] = None,
        assume_role: typing.Optional[typing.Union[OssAssumeRole, typing.Dict[builtins.str, typing.Any]]] = None,
        assume_role_policy: typing.Optional[builtins.str] = None,
        assume_role_role_arn: typing.Optional[builtins.str] = None,
        assume_role_session_expiration: typing.Optional[jsii.Number] = None,
        assume_role_session_name: typing.Optional[builtins.str] = None,
        ecs_role_name: typing.Optional[builtins.str] = None,
        encrypt: typing.Optional[builtins.bool] = None,
        endpoint: typing.Optional[builtins.str] = None,
        key: typing.Optional[builtins.str] = None,
        prefix: typing.Optional[builtins.str] = None,
        profile: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        secret_key: typing.Optional[builtins.str] = None,
        security_token: typing.Optional[builtins.str] = None,
        shared_credentials_file: typing.Optional[builtins.str] = None,
        sts_endpoint: typing.Optional[builtins.str] = None,
        tablestore_endpoint: typing.Optional[builtins.str] = None,
        tablestore_table: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param bucket: (experimental) (Required) The name of the OSS bucket.
        :param access_key: (experimental) (Optional) Alibaba Cloud access key. It supports environment variables ALICLOUD_ACCESS_KEY and ALICLOUD_ACCESS_KEY_ID.
        :param acl: (experimental) (Optional) Object ACL to be applied to the state file.
        :param assume_role: 
        :param assume_role_policy: (experimental) (Optional, Available in 1.1.0+) A more restrictive policy to apply to the temporary credentials. This gives you a way to further restrict the permissions for the resulting temporary security credentials. You cannot use this policy to grant permissions that exceed those of the role that is being assumed.
        :param assume_role_role_arn: (experimental) (Optional, Available in 1.1.0+) The ARN of the role to assume. If ARN is set to an empty string, it does not perform role switching. It supports the environment variable ALICLOUD_ASSUME_ROLE_ARN. Terraform executes configuration on account with provided credentials.
        :param assume_role_session_expiration: (experimental) (Optional, Available in 1.1.0+) The time after which the established session for assuming role expires. Valid value range: [900-3600] seconds. Default to 3600 (in this case Alibaba Cloud uses its own default value). It supports environment variable ALICLOUD_ASSUME_ROLE_SESSION_EXPIRATION.
        :param assume_role_session_name: (experimental) (Optional, Available in 1.1.0+) The session name to use when assuming the role. If omitted, 'terraform' is passed to the AssumeRole call as session name. It supports environment variable ALICLOUD_ASSUME_ROLE_SESSION_NAME.
        :param ecs_role_name: (experimental) (Optional, Available in 0.12.14+) The RAM Role Name attached on a ECS instance for API operations. You can retrieve this from the 'Access Control' section of the Alibaba Cloud console.
        :param encrypt: (experimental) (Optional) Whether to enable server side encryption of the state file. If it is true, OSS will use 'AES256' encryption algorithm to encrypt state file.
        :param endpoint: (experimental) (Optional) A custom endpoint for the OSS API. It supports environment variables ALICLOUD_OSS_ENDPOINT and OSS_ENDPOINT.
        :param key: (experimental) (Optional) The name of the state file. Defaults to terraform.tfstate.
        :param prefix: (experimental) (Optional) The path directory of the state file will be stored. Default to "env:".
        :param profile: (experimental) (Optional, Available in 0.12.8+) This is the Alibaba Cloud profile name as set in the shared credentials file. It can also be sourced from the ALICLOUD_PROFILE environment variable.
        :param region: (experimental) (Optional) The region of the OSS bucket. It supports environment variables ALICLOUD_REGION and ALICLOUD_DEFAULT_REGION.
        :param secret_key: (experimental) (Optional) Alibaba Cloud secret access key. It supports environment variables ALICLOUD_SECRET_KEY and ALICLOUD_ACCESS_KEY_SECRET.
        :param security_token: (experimental) (Optional) STS access token. It supports environment variable ALICLOUD_SECURITY_TOKEN.
        :param shared_credentials_file: (experimental) (Optional, Available in 0.12.8+) This is the path to the shared credentials file. It can also be sourced from the ALICLOUD_SHARED_CREDENTIALS_FILE environment variable. If this is not set and a profile is specified, ~/.aliyun/config.json will be used.
        :param sts_endpoint: (experimental) (Optional, Available in 1.0.11+) Custom endpoint for the AliCloud Security Token Service (STS) API. It supports environment variable ALICLOUD_STS_ENDPOINT.
        :param tablestore_endpoint: (experimental) (Optional) A custom endpoint for the TableStore API.
        :param tablestore_table: (experimental) (Optional) A TableStore table for state locking and consistency. The table must have a primary key named LockID of type String.

        :stability: experimental
        '''
        if isinstance(assume_role, dict):
            assume_role = OssAssumeRole(**assume_role)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3f73f68ebdb166b82b289eec56d99510aa006cdf1bb0518dc28aefc44d49ff4a)
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument access_key", value=access_key, expected_type=type_hints["access_key"])
            check_type(argname="argument acl", value=acl, expected_type=type_hints["acl"])
            check_type(argname="argument assume_role", value=assume_role, expected_type=type_hints["assume_role"])
            check_type(argname="argument assume_role_policy", value=assume_role_policy, expected_type=type_hints["assume_role_policy"])
            check_type(argname="argument assume_role_role_arn", value=assume_role_role_arn, expected_type=type_hints["assume_role_role_arn"])
            check_type(argname="argument assume_role_session_expiration", value=assume_role_session_expiration, expected_type=type_hints["assume_role_session_expiration"])
            check_type(argname="argument assume_role_session_name", value=assume_role_session_name, expected_type=type_hints["assume_role_session_name"])
            check_type(argname="argument ecs_role_name", value=ecs_role_name, expected_type=type_hints["ecs_role_name"])
            check_type(argname="argument encrypt", value=encrypt, expected_type=type_hints["encrypt"])
            check_type(argname="argument endpoint", value=endpoint, expected_type=type_hints["endpoint"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
            check_type(argname="argument profile", value=profile, expected_type=type_hints["profile"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument secret_key", value=secret_key, expected_type=type_hints["secret_key"])
            check_type(argname="argument security_token", value=security_token, expected_type=type_hints["security_token"])
            check_type(argname="argument shared_credentials_file", value=shared_credentials_file, expected_type=type_hints["shared_credentials_file"])
            check_type(argname="argument sts_endpoint", value=sts_endpoint, expected_type=type_hints["sts_endpoint"])
            check_type(argname="argument tablestore_endpoint", value=tablestore_endpoint, expected_type=type_hints["tablestore_endpoint"])
            check_type(argname="argument tablestore_table", value=tablestore_table, expected_type=type_hints["tablestore_table"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bucket": bucket,
        }
        if access_key is not None:
            self._values["access_key"] = access_key
        if acl is not None:
            self._values["acl"] = acl
        if assume_role is not None:
            self._values["assume_role"] = assume_role
        if assume_role_policy is not None:
            self._values["assume_role_policy"] = assume_role_policy
        if assume_role_role_arn is not None:
            self._values["assume_role_role_arn"] = assume_role_role_arn
        if assume_role_session_expiration is not None:
            self._values["assume_role_session_expiration"] = assume_role_session_expiration
        if assume_role_session_name is not None:
            self._values["assume_role_session_name"] = assume_role_session_name
        if ecs_role_name is not None:
            self._values["ecs_role_name"] = ecs_role_name
        if encrypt is not None:
            self._values["encrypt"] = encrypt
        if endpoint is not None:
            self._values["endpoint"] = endpoint
        if key is not None:
            self._values["key"] = key
        if prefix is not None:
            self._values["prefix"] = prefix
        if profile is not None:
            self._values["profile"] = profile
        if region is not None:
            self._values["region"] = region
        if secret_key is not None:
            self._values["secret_key"] = secret_key
        if security_token is not None:
            self._values["security_token"] = security_token
        if shared_credentials_file is not None:
            self._values["shared_credentials_file"] = shared_credentials_file
        if sts_endpoint is not None:
            self._values["sts_endpoint"] = sts_endpoint
        if tablestore_endpoint is not None:
            self._values["tablestore_endpoint"] = tablestore_endpoint
        if tablestore_table is not None:
            self._values["tablestore_table"] = tablestore_table

    @builtins.property
    def bucket(self) -> builtins.str:
        '''(experimental) (Required) The name of the OSS bucket.

        :stability: experimental
        '''
        result = self._values.get("bucket")
        assert result is not None, "Required property 'bucket' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def access_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Alibaba Cloud access key.

        It supports environment variables ALICLOUD_ACCESS_KEY and ALICLOUD_ACCESS_KEY_ID.

        :stability: experimental
        '''
        result = self._values.get("access_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def acl(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Object ACL to be applied to the state file.

        :stability: experimental
        '''
        result = self._values.get("acl")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def assume_role(self) -> typing.Optional[OssAssumeRole]:
        '''
        :deprecated: Use flattened assume role options

        :stability: deprecated
        '''
        result = self._values.get("assume_role")
        return typing.cast(typing.Optional[OssAssumeRole], result)

    @builtins.property
    def assume_role_policy(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional, Available in 1.1.0+) A more restrictive policy to apply to the temporary credentials. This gives you a way to further restrict the permissions for the resulting temporary security credentials. You cannot use this policy to grant permissions that exceed those of the role that is being assumed.

        :stability: experimental
        '''
        result = self._values.get("assume_role_policy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def assume_role_role_arn(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional, Available in 1.1.0+) The ARN of the role to assume. If ARN is set to an empty string, it does not perform role switching. It supports the environment variable ALICLOUD_ASSUME_ROLE_ARN. Terraform executes configuration on account with provided credentials.

        :stability: experimental
        '''
        result = self._values.get("assume_role_role_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def assume_role_session_expiration(self) -> typing.Optional[jsii.Number]:
        '''(experimental) (Optional, Available in 1.1.0+) The time after which the established session for assuming role expires. Valid value range: [900-3600] seconds. Default to 3600 (in this case Alibaba Cloud uses its own default value). It supports environment variable ALICLOUD_ASSUME_ROLE_SESSION_EXPIRATION.

        :stability: experimental
        '''
        result = self._values.get("assume_role_session_expiration")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def assume_role_session_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional, Available in 1.1.0+) The session name to use when assuming the role. If omitted, 'terraform' is passed to the AssumeRole call as session name. It supports environment variable ALICLOUD_ASSUME_ROLE_SESSION_NAME.

        :stability: experimental
        '''
        result = self._values.get("assume_role_session_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ecs_role_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional, Available in 0.12.14+) The RAM Role Name attached on a ECS instance for API operations. You can retrieve this from the 'Access Control' section of the Alibaba Cloud console.

        :stability: experimental
        '''
        result = self._values.get("ecs_role_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def encrypt(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Whether to enable server side encryption of the state file.

        If it is true, OSS will use 'AES256' encryption algorithm to encrypt state file.

        :stability: experimental
        '''
        result = self._values.get("encrypt")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A custom endpoint for the OSS API.

        It supports environment variables ALICLOUD_OSS_ENDPOINT and OSS_ENDPOINT.

        :stability: experimental
        '''
        result = self._values.get("endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The name of the state file.

        Defaults to terraform.tfstate.

        :stability: experimental
        '''
        result = self._values.get("key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def prefix(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The path directory of the state file will be stored.

        Default to "env:".

        :stability: experimental
        '''
        result = self._values.get("prefix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def profile(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional, Available in 0.12.8+) This is the Alibaba Cloud profile name as set in the shared credentials file. It can also be sourced from the ALICLOUD_PROFILE environment variable.

        :stability: experimental
        '''
        result = self._values.get("profile")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The region of the OSS bucket.

        It supports environment variables ALICLOUD_REGION and ALICLOUD_DEFAULT_REGION.

        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def secret_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Alibaba Cloud secret access key.

        It supports environment variables ALICLOUD_SECRET_KEY and ALICLOUD_ACCESS_KEY_SECRET.

        :stability: experimental
        '''
        result = self._values.get("secret_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def security_token(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) STS access token.

        It supports environment variable ALICLOUD_SECURITY_TOKEN.

        :stability: experimental
        '''
        result = self._values.get("security_token")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def shared_credentials_file(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional, Available in 0.12.8+) This is the path to the shared credentials file. It can also be sourced from the ALICLOUD_SHARED_CREDENTIALS_FILE environment variable. If this is not set and a profile is specified, ~/.aliyun/config.json will be used.

        :stability: experimental
        '''
        result = self._values.get("shared_credentials_file")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sts_endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional, Available in 1.0.11+) Custom endpoint for the AliCloud Security Token Service (STS) API. It supports environment variable ALICLOUD_STS_ENDPOINT.

        :stability: experimental
        '''
        result = self._values.get("sts_endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tablestore_endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A custom endpoint for the TableStore API.

        :stability: experimental
        '''
        result = self._values.get("tablestore_endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tablestore_table(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A TableStore table for state locking and consistency.

        The table must have a primary key named LockID of type String.

        :stability: experimental
        '''
        result = self._values.get("tablestore_table")
        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 "OssBackendConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.PgBackendConfig",
    jsii_struct_bases=[],
    name_mapping={
        "conn_str": "connStr",
        "schema_name": "schemaName",
        "skip_index_creation": "skipIndexCreation",
        "skip_schema_creation": "skipSchemaCreation",
        "skip_table_creation": "skipTableCreation",
    },
)
class PgBackendConfig:
    def __init__(
        self,
        *,
        conn_str: builtins.str,
        schema_name: typing.Optional[builtins.str] = None,
        skip_index_creation: typing.Optional[builtins.bool] = None,
        skip_schema_creation: typing.Optional[builtins.bool] = None,
        skip_table_creation: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param conn_str: (experimental) Postgres connection string; a postgres:// URL. The PG_CONN_STR and standard libpq environment variables can also be used to indicate how to connect to the PostgreSQL database.
        :param schema_name: (experimental) Name of the automatically-managed Postgres schema, default to terraform_remote_state. Can also be set using the PG_SCHEMA_NAME environment variable.
        :param skip_index_creation: (experimental) If set to true, the Postgres index must already exist. Can also be set using the PG_SKIP_INDEX_CREATION environment variable. Terraform won't try to create the index, this is useful when it has already been created by a database administrator.
        :param skip_schema_creation: (experimental) If set to true, the Postgres schema must already exist. Can also be set using the PG_SKIP_SCHEMA_CREATION environment variable. Terraform won't try to create the schema, this is useful when it has already been created by a database administrator.
        :param skip_table_creation: (experimental) If set to true, the Postgres table must already exist. Can also be set using the PG_SKIP_TABLE_CREATION environment variable. Terraform won't try to create the table, this is useful when it has already been created by a database administrator.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7030236e50c7b9284053ddfef788c040111f5242244cef912dfd6669ff1a3517)
            check_type(argname="argument conn_str", value=conn_str, expected_type=type_hints["conn_str"])
            check_type(argname="argument schema_name", value=schema_name, expected_type=type_hints["schema_name"])
            check_type(argname="argument skip_index_creation", value=skip_index_creation, expected_type=type_hints["skip_index_creation"])
            check_type(argname="argument skip_schema_creation", value=skip_schema_creation, expected_type=type_hints["skip_schema_creation"])
            check_type(argname="argument skip_table_creation", value=skip_table_creation, expected_type=type_hints["skip_table_creation"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "conn_str": conn_str,
        }
        if schema_name is not None:
            self._values["schema_name"] = schema_name
        if skip_index_creation is not None:
            self._values["skip_index_creation"] = skip_index_creation
        if skip_schema_creation is not None:
            self._values["skip_schema_creation"] = skip_schema_creation
        if skip_table_creation is not None:
            self._values["skip_table_creation"] = skip_table_creation

    @builtins.property
    def conn_str(self) -> builtins.str:
        '''(experimental) Postgres connection string;

        a postgres:// URL.
        The PG_CONN_STR and standard libpq environment variables can also be used to indicate how to connect to the PostgreSQL database.

        :stability: experimental
        '''
        result = self._values.get("conn_str")
        assert result is not None, "Required property 'conn_str' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def schema_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Name of the automatically-managed Postgres schema, default to terraform_remote_state.

        Can also be set using the PG_SCHEMA_NAME environment variable.

        :stability: experimental
        '''
        result = self._values.get("schema_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def skip_index_creation(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If set to true, the Postgres index must already exist.

        Can also be set using the PG_SKIP_INDEX_CREATION environment variable.
        Terraform won't try to create the index, this is useful when it has already been created by a database administrator.

        :stability: experimental
        '''
        result = self._values.get("skip_index_creation")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def skip_schema_creation(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If set to true, the Postgres schema must already exist.

        Can also be set using the PG_SKIP_SCHEMA_CREATION environment variable.
        Terraform won't try to create the schema, this is useful when it has already been created by a database administrator.

        :stability: experimental
        '''
        result = self._values.get("skip_schema_creation")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def skip_table_creation(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If set to true, the Postgres table must already exist.

        Can also be set using the PG_SKIP_TABLE_CREATION environment variable.
        Terraform won't try to create the table, this is useful when it has already been created by a database administrator.

        :stability: experimental
        '''
        result = self._values.get("skip_table_creation")
        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 "PgBackendConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IRemoteWorkspace)
class PrefixedRemoteWorkspaces(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.PrefixedRemoteWorkspaces",
):
    '''
    :stability: experimental
    '''

    def __init__(self, prefix: builtins.str) -> None:
        '''
        :param prefix: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__573c03fcf5c3ff78fb49e94825b0cc30fd008ddc494378b2e734176af7539102)
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
        jsii.create(self.__class__, self, [prefix])

    @builtins.property
    @jsii.member(jsii_name="prefix")
    def prefix(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "prefix"))

    @prefix.setter
    def prefix(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5cd7aadbfc568a3ab80aac53aa6dc1e1a8fd16849e803afe8cac18881adb06f5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "prefix", value) # pyright: ignore[reportArgumentType]


@jsii.data_type(
    jsii_type="cdktn.RemoteBackendConfig",
    jsii_struct_bases=[],
    name_mapping={
        "organization": "organization",
        "workspaces": "workspaces",
        "hostname": "hostname",
        "token": "token",
    },
)
class RemoteBackendConfig:
    def __init__(
        self,
        *,
        organization: builtins.str,
        workspaces: IRemoteWorkspace,
        hostname: typing.Optional[builtins.str] = None,
        token: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param organization: 
        :param workspaces: 
        :param hostname: 
        :param token: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5dbbfda7a87092b423bd7fff1db9557e142f36d1dfc46f423f9a29a94ac582e7)
            check_type(argname="argument organization", value=organization, expected_type=type_hints["organization"])
            check_type(argname="argument workspaces", value=workspaces, expected_type=type_hints["workspaces"])
            check_type(argname="argument hostname", value=hostname, expected_type=type_hints["hostname"])
            check_type(argname="argument token", value=token, expected_type=type_hints["token"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "organization": organization,
            "workspaces": workspaces,
        }
        if hostname is not None:
            self._values["hostname"] = hostname
        if token is not None:
            self._values["token"] = token

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

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

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

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


@jsii.data_type(
    jsii_type="cdktn.RemoteExecProvisioner",
    jsii_struct_bases=[],
    name_mapping={
        "type": "type",
        "connection": "connection",
        "inline": "inline",
        "script": "script",
        "scripts": "scripts",
    },
)
class RemoteExecProvisioner:
    def __init__(
        self,
        *,
        type: builtins.str,
        connection: typing.Optional[typing.Union[typing.Union["SSHProvisionerConnection", typing.Dict[builtins.str, typing.Any]], typing.Union["WinrmProvisionerConnection", typing.Dict[builtins.str, typing.Any]]]] = None,
        inline: typing.Optional[typing.Sequence[builtins.str]] = None,
        script: typing.Optional[builtins.str] = None,
        scripts: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> None:
        '''(experimental) The remote-exec provisioner invokes a script on a remote resource after it is created.

        This can be used to run a configuration management tool, bootstrap into a cluster, etc
        The remote-exec provisioner requires a connection and supports both ssh and winrm.

        See {@link https://developer.hashicorp.com/terraform/language/resources/provisioners/remote-exec remote-exec}

        :param type: 
        :param connection: (experimental) Most provisioners require access to the remote resource via SSH or WinRM and expect a nested connection block with details about how to connect. A connection must be provided here or in the parent resource.
        :param inline: (experimental) This is a list of command strings. They are executed in the order they are provided. This cannot be provided with script or scripts.
        :param script: (experimental) This is a path (relative or absolute) to a local script that will be copied to the remote resource and then executed. This cannot be provided with inline or scripts.
        :param scripts: (experimental) This is a list of paths (relative or absolute) to local scripts that will be copied to the remote resource and then executed. They are executed in the order they are provided. This cannot be provided with inline or script.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ecc14f28894fb6b625d68e40edc32b1e948e36b69cd69b665db95b75fce83a59)
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument connection", value=connection, expected_type=type_hints["connection"])
            check_type(argname="argument inline", value=inline, expected_type=type_hints["inline"])
            check_type(argname="argument script", value=script, expected_type=type_hints["script"])
            check_type(argname="argument scripts", value=scripts, expected_type=type_hints["scripts"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "type": type,
        }
        if connection is not None:
            self._values["connection"] = connection
        if inline is not None:
            self._values["inline"] = inline
        if script is not None:
            self._values["script"] = script
        if scripts is not None:
            self._values["scripts"] = scripts

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

    @builtins.property
    def connection(
        self,
    ) -> typing.Optional[typing.Union["SSHProvisionerConnection", "WinrmProvisionerConnection"]]:
        '''(experimental) Most provisioners require access to the remote resource via SSH or WinRM and expect a nested connection block with details about how to connect.

        A connection must be provided here or in the parent resource.

        :stability: experimental
        '''
        result = self._values.get("connection")
        return typing.cast(typing.Optional[typing.Union["SSHProvisionerConnection", "WinrmProvisionerConnection"]], result)

    @builtins.property
    def inline(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This is a list of command strings.

        They are executed in the order they are provided.
        This cannot be provided with script or scripts.

        :stability: experimental
        '''
        result = self._values.get("inline")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def script(self) -> typing.Optional[builtins.str]:
        '''(experimental) This is a path (relative or absolute) to a local script that will be copied to the remote resource and then executed.

        This cannot be provided with inline or scripts.

        :stability: experimental
        '''
        result = self._values.get("script")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def scripts(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This is a list of paths (relative or absolute) to local scripts that will be copied to the remote resource and then executed.

        They are executed in the order they are provided.
        This cannot be provided with inline or script.

        :stability: experimental
        '''
        result = self._values.get("scripts")
        return typing.cast(typing.Optional[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 "RemoteExecProvisioner(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.ResolveOptions",
    jsii_struct_bases=[],
    name_mapping={"resolver": "resolver", "scope": "scope", "preparing": "preparing"},
)
class ResolveOptions:
    def __init__(
        self,
        *,
        resolver: ITokenResolver,
        scope: _constructs_77d1e7e8.IConstruct,
        preparing: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''(experimental) Options to the resolve() operation.

        NOT the same as the ResolveContext; ResolveContext is exposed to Token
        implementors and resolution hooks, whereas this struct is just to bundle
        a number of things that would otherwise be arguments to resolve() in a
        readable way.

        :param resolver: (experimental) The resolver to apply to any resolvable tokens found.
        :param scope: (experimental) The scope from which resolution is performed.
        :param preparing: (experimental) Whether the resolution is being executed during the prepare phase or not. Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c877f2c55ac3ed4cc385f946ff7b4d63535735c582a7c62c0f0748faf1dcff8e)
            check_type(argname="argument resolver", value=resolver, expected_type=type_hints["resolver"])
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument preparing", value=preparing, expected_type=type_hints["preparing"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "resolver": resolver,
            "scope": scope,
        }
        if preparing is not None:
            self._values["preparing"] = preparing

    @builtins.property
    def resolver(self) -> ITokenResolver:
        '''(experimental) The resolver to apply to any resolvable tokens found.

        :stability: experimental
        '''
        result = self._values.get("resolver")
        assert result is not None, "Required property 'resolver' is missing"
        return typing.cast(ITokenResolver, result)

    @builtins.property
    def scope(self) -> _constructs_77d1e7e8.IConstruct:
        '''(experimental) The scope from which resolution is performed.

        :stability: experimental
        '''
        result = self._values.get("scope")
        assert result is not None, "Required property 'scope' is missing"
        return typing.cast(_constructs_77d1e7e8.IConstruct, result)

    @builtins.property
    def preparing(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Whether the resolution is being executed during the prepare phase or not.

        :default: false

        :stability: experimental
        '''
        result = self._values.get("preparing")
        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 "ResolveOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IResource)
class Resource(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="cdktn.Resource",
):
    '''(deprecated) A construct which represents a resource.

    :deprecated: - Please use Construct from the constructs package instead.

    :stability: deprecated
    '''

    def __init__(self, scope: _constructs_77d1e7e8.Construct, id: builtins.str) -> None:
        '''
        :param scope: -
        :param id: -

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__35e74dd98299db0cd1e159e20557edf5c3ee11baf42aca7e55714a29c00c29e9)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        jsii.create(self.__class__, self, [scope, id])

    @builtins.property
    @jsii.member(jsii_name="stack")
    def stack(self) -> "TerraformStack":
        '''(deprecated) The stack in which this resource is defined.

        :stability: deprecated
        '''
        return typing.cast("TerraformStack", jsii.get(self, "stack"))


class _ResourceProxy(Resource):
    pass

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


@jsii.data_type(
    jsii_type="cdktn.S3BackendAssumeRoleConfig",
    jsii_struct_bases=[],
    name_mapping={
        "role_arn": "roleArn",
        "duration": "duration",
        "external_id": "externalId",
        "policy": "policy",
        "policy_arns": "policyArns",
        "session_name": "sessionName",
        "source_identity": "sourceIdentity",
        "tags": "tags",
        "transitive_tag_keys": "transitiveTagKeys",
    },
)
class S3BackendAssumeRoleConfig:
    def __init__(
        self,
        *,
        role_arn: builtins.str,
        duration: typing.Optional[builtins.str] = None,
        external_id: typing.Optional[builtins.str] = None,
        policy: typing.Optional[builtins.str] = None,
        policy_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
        session_name: typing.Optional[builtins.str] = None,
        source_identity: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        transitive_tag_keys: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> None:
        '''
        :param role_arn: (experimental) (Required) Amazon Resource Name (ARN) of the IAM Role to assume.
        :param duration: (experimental) (Optional) The duration individual credentials will be valid. Credentials are automatically renewed up to the maximum defined by the AWS account. Specified using the format hms with any unit being optional. For example, an hour and a half can be specified as 1h30m or 90m. Must be between 15 minutes (15m) and 12 hours (12h).
        :param external_id: (experimental) (Optional) External identifier to use when assuming the role.
        :param policy: (experimental) (Optional) IAM Policy JSON describing further restricting permissions for the IAM Role being assumed.
        :param policy_arns: (experimental) (Optional) Set of Amazon Resource Names (ARNs) of IAM Policies describing further restricting permissions for the IAM Role being assumed.
        :param session_name: (experimental) (Optional) Session name to use when assuming the role.
        :param source_identity: (experimental) (Optional) Source identity specified by the principal assuming the.
        :param tags: (experimental) (Optional) Map of assume role session tags.
        :param transitive_tag_keys: (experimental) (Optional) Set of assume role session tag keys to pass to any subsequent sessions.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f5dd405820bfc7d96d04fd9d3eb9ead67c37a0307f4714394fff5a774c892cb5)
            check_type(argname="argument role_arn", value=role_arn, expected_type=type_hints["role_arn"])
            check_type(argname="argument duration", value=duration, expected_type=type_hints["duration"])
            check_type(argname="argument external_id", value=external_id, expected_type=type_hints["external_id"])
            check_type(argname="argument policy", value=policy, expected_type=type_hints["policy"])
            check_type(argname="argument policy_arns", value=policy_arns, expected_type=type_hints["policy_arns"])
            check_type(argname="argument session_name", value=session_name, expected_type=type_hints["session_name"])
            check_type(argname="argument source_identity", value=source_identity, expected_type=type_hints["source_identity"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument transitive_tag_keys", value=transitive_tag_keys, expected_type=type_hints["transitive_tag_keys"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "role_arn": role_arn,
        }
        if duration is not None:
            self._values["duration"] = duration
        if external_id is not None:
            self._values["external_id"] = external_id
        if policy is not None:
            self._values["policy"] = policy
        if policy_arns is not None:
            self._values["policy_arns"] = policy_arns
        if session_name is not None:
            self._values["session_name"] = session_name
        if source_identity is not None:
            self._values["source_identity"] = source_identity
        if tags is not None:
            self._values["tags"] = tags
        if transitive_tag_keys is not None:
            self._values["transitive_tag_keys"] = transitive_tag_keys

    @builtins.property
    def role_arn(self) -> builtins.str:
        '''(experimental) (Required) Amazon Resource Name (ARN) of the IAM Role to assume.

        :stability: experimental
        '''
        result = self._values.get("role_arn")
        assert result is not None, "Required property 'role_arn' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def duration(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The duration individual credentials will be valid.

        Credentials are automatically renewed up to the maximum defined by the AWS account.
        Specified using the format hms with any unit being optional.
        For example, an hour and a half can be specified as 1h30m or 90m.
        Must be between 15 minutes (15m) and 12 hours (12h).

        :stability: experimental
        '''
        result = self._values.get("duration")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def external_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) External identifier to use when assuming the role.

        :stability: experimental
        '''
        result = self._values.get("external_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def policy(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) IAM Policy JSON describing further restricting permissions for the IAM Role being assumed.

        :stability: experimental
        '''
        result = self._values.get("policy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def policy_arns(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) (Optional) Set of Amazon Resource Names (ARNs) of IAM Policies describing further restricting permissions for the IAM Role being assumed.

        :stability: experimental
        '''
        result = self._values.get("policy_arns")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def session_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Session name to use when assuming the role.

        :stability: experimental
        '''
        result = self._values.get("session_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def source_identity(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Source identity specified by the principal assuming the.

        :stability: experimental
        '''
        result = self._values.get("source_identity")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        '''(experimental) (Optional) Map of assume role session tags.

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

    @builtins.property
    def transitive_tag_keys(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) (Optional) Set of assume role session tag keys to pass to any subsequent sessions.

        :stability: experimental
        '''
        result = self._values.get("transitive_tag_keys")
        return typing.cast(typing.Optional[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 "S3BackendAssumeRoleConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.S3BackendAssumeRoleWithWebIdentityConfig",
    jsii_struct_bases=[],
    name_mapping={
        "duration": "duration",
        "policy": "policy",
        "policy_arns": "policyArns",
        "role_arn": "roleArn",
        "session_name": "sessionName",
        "web_identity_token": "webIdentityToken",
        "web_identity_token_file": "webIdentityTokenFile",
    },
)
class S3BackendAssumeRoleWithWebIdentityConfig:
    def __init__(
        self,
        *,
        duration: typing.Optional[builtins.str] = None,
        policy: typing.Optional[builtins.str] = None,
        policy_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
        role_arn: typing.Optional[builtins.str] = None,
        session_name: typing.Optional[builtins.str] = None,
        web_identity_token: typing.Optional[builtins.str] = None,
        web_identity_token_file: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param duration: (experimental) (Optional) The duration individual credentials will be valid. Credentials are automatically renewed up to the maximum defined by the AWS account. Specified using the format hms with any unit being optional. For example, an hour and a half can be specified as 1h30m or 90m. Must be between 15 minutes (15m) and 12 hours (12h).
        :param policy: (experimental) (Optional) IAM Policy JSON describing further restricting permissions for the IAM Role being assumed.
        :param policy_arns: (experimental) (Optional) Set of Amazon Resource Names (ARNs) of IAM Policies describing further restricting permissions for the IAM Role being assumed.
        :param role_arn: (experimental) (Required) Amazon Resource Name (ARN) of the IAM Role to assume. Can also be set with the AWS_ROLE_ARN environment variable.
        :param session_name: (experimental) (Optional) Session name to use when assuming the role. Can also be set with the AWS_ROLE_SESSION_NAME environment variable.
        :param web_identity_token: (experimental) (Optional) The value of a web identity token from an OpenID Connect (OIDC) or OAuth provider. One of web_identity_token or web_identity_token_file is required.
        :param web_identity_token_file: (experimental) (Optional) File containing a web identity token from an OpenID Connect (OIDC) or OAuth provider. One of web_identity_token_file or web_identity_token is required. Can also be set with the AWS_WEB_IDENTITY_TOKEN_FILE environment variable.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__32c00439efde8bbe4e42d68097b869b0426dcbdac67c39fdc7c2d0796d272d7b)
            check_type(argname="argument duration", value=duration, expected_type=type_hints["duration"])
            check_type(argname="argument policy", value=policy, expected_type=type_hints["policy"])
            check_type(argname="argument policy_arns", value=policy_arns, expected_type=type_hints["policy_arns"])
            check_type(argname="argument role_arn", value=role_arn, expected_type=type_hints["role_arn"])
            check_type(argname="argument session_name", value=session_name, expected_type=type_hints["session_name"])
            check_type(argname="argument web_identity_token", value=web_identity_token, expected_type=type_hints["web_identity_token"])
            check_type(argname="argument web_identity_token_file", value=web_identity_token_file, expected_type=type_hints["web_identity_token_file"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if duration is not None:
            self._values["duration"] = duration
        if policy is not None:
            self._values["policy"] = policy
        if policy_arns is not None:
            self._values["policy_arns"] = policy_arns
        if role_arn is not None:
            self._values["role_arn"] = role_arn
        if session_name is not None:
            self._values["session_name"] = session_name
        if web_identity_token is not None:
            self._values["web_identity_token"] = web_identity_token
        if web_identity_token_file is not None:
            self._values["web_identity_token_file"] = web_identity_token_file

    @builtins.property
    def duration(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The duration individual credentials will be valid.

        Credentials are automatically renewed up to the maximum defined by the AWS account.
        Specified using the format hms with any unit being optional.
        For example, an hour and a half can be specified as 1h30m or 90m.
        Must be between 15 minutes (15m) and 12 hours (12h).

        :stability: experimental
        '''
        result = self._values.get("duration")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def policy(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) IAM Policy JSON describing further restricting permissions for the IAM Role being assumed.

        :stability: experimental
        '''
        result = self._values.get("policy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def policy_arns(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) (Optional) Set of Amazon Resource Names (ARNs) of IAM Policies describing further restricting permissions for the IAM Role being assumed.

        :stability: experimental
        '''
        result = self._values.get("policy_arns")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def role_arn(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Required) Amazon Resource Name (ARN) of the IAM Role to assume.

        Can also be set with the AWS_ROLE_ARN environment variable.

        :stability: experimental
        '''
        result = self._values.get("role_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def session_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Session name to use when assuming the role.

        Can also be set with the AWS_ROLE_SESSION_NAME environment variable.

        :stability: experimental
        '''
        result = self._values.get("session_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def web_identity_token(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The value of a web identity token from an OpenID Connect (OIDC) or OAuth provider.

        One of web_identity_token or web_identity_token_file is required.

        :stability: experimental
        '''
        result = self._values.get("web_identity_token")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def web_identity_token_file(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) File containing a web identity token from an OpenID Connect (OIDC) or OAuth provider.

        One of web_identity_token_file or web_identity_token is required.
        Can also be set with the AWS_WEB_IDENTITY_TOKEN_FILE environment variable.

        :stability: experimental
        '''
        result = self._values.get("web_identity_token_file")
        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 "S3BackendAssumeRoleWithWebIdentityConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.S3BackendConfig",
    jsii_struct_bases=[],
    name_mapping={
        "bucket": "bucket",
        "key": "key",
        "access_key": "accessKey",
        "acl": "acl",
        "allowed_account_ids": "allowedAccountIds",
        "assume_role": "assumeRole",
        "assume_role_policy": "assumeRolePolicy",
        "assume_role_policy_arns": "assumeRolePolicyArns",
        "assume_role_tags": "assumeRoleTags",
        "assume_role_transitive_tag_keys": "assumeRoleTransitiveTagKeys",
        "assume_role_with_web_identity": "assumeRoleWithWebIdentity",
        "custom_ca_bundle": "customCaBundle",
        "dynamodb_endpoint": "dynamodbEndpoint",
        "dynamodb_table": "dynamodbTable",
        "ec2_metadata_service_endpoint": "ec2MetadataServiceEndpoint",
        "ec2_metadata_service_endpoint_mode": "ec2MetadataServiceEndpointMode",
        "encrypt": "encrypt",
        "endpoint": "endpoint",
        "endpoints": "endpoints",
        "external_id": "externalId",
        "forbidden_account_ids": "forbiddenAccountIds",
        "force_path_style": "forcePathStyle",
        "http_proxy": "httpProxy",
        "https_proxy": "httpsProxy",
        "iam_endpoint": "iamEndpoint",
        "insecure": "insecure",
        "kms_key_id": "kmsKeyId",
        "max_retries": "maxRetries",
        "no_proxy": "noProxy",
        "profile": "profile",
        "region": "region",
        "retry_mode": "retryMode",
        "role_arn": "roleArn",
        "secret_key": "secretKey",
        "session_name": "sessionName",
        "shared_config_files": "sharedConfigFiles",
        "shared_credentials_file": "sharedCredentialsFile",
        "shared_credentials_files": "sharedCredentialsFiles",
        "skip_credentials_validation": "skipCredentialsValidation",
        "skip_metadata_api_check": "skipMetadataApiCheck",
        "skip_region_validation": "skipRegionValidation",
        "skip_requesting_account_id": "skipRequestingAccountId",
        "skip_s3_checksum": "skipS3Checksum",
        "sse_customer_key": "sseCustomerKey",
        "sts_endpoint": "stsEndpoint",
        "sts_region": "stsRegion",
        "token": "token",
        "use_legacy_workflow": "useLegacyWorkflow",
        "use_path_style": "usePathStyle",
        "workspace_key_prefix": "workspaceKeyPrefix",
    },
)
class S3BackendConfig:
    def __init__(
        self,
        *,
        bucket: builtins.str,
        key: builtins.str,
        access_key: typing.Optional[builtins.str] = None,
        acl: typing.Optional[builtins.str] = None,
        allowed_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        assume_role: typing.Optional[typing.Union[S3BackendAssumeRoleConfig, typing.Dict[builtins.str, typing.Any]]] = None,
        assume_role_policy: typing.Optional[builtins.str] = None,
        assume_role_policy_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
        assume_role_tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        assume_role_transitive_tag_keys: typing.Optional[typing.Sequence[builtins.str]] = None,
        assume_role_with_web_identity: typing.Optional[typing.Union[S3BackendAssumeRoleWithWebIdentityConfig, typing.Dict[builtins.str, typing.Any]]] = None,
        custom_ca_bundle: typing.Optional[builtins.str] = None,
        dynamodb_endpoint: typing.Optional[builtins.str] = None,
        dynamodb_table: typing.Optional[builtins.str] = None,
        ec2_metadata_service_endpoint: typing.Optional[builtins.str] = None,
        ec2_metadata_service_endpoint_mode: typing.Optional[builtins.str] = None,
        encrypt: typing.Optional[builtins.bool] = None,
        endpoint: typing.Optional[builtins.str] = None,
        endpoints: typing.Optional[typing.Union["S3BackendEndpointConfig", typing.Dict[builtins.str, typing.Any]]] = None,
        external_id: typing.Optional[builtins.str] = None,
        forbidden_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        force_path_style: typing.Optional[builtins.bool] = None,
        http_proxy: typing.Optional[builtins.str] = None,
        https_proxy: typing.Optional[builtins.str] = None,
        iam_endpoint: typing.Optional[builtins.str] = None,
        insecure: typing.Optional[builtins.bool] = None,
        kms_key_id: typing.Optional[builtins.str] = None,
        max_retries: typing.Optional[jsii.Number] = None,
        no_proxy: typing.Optional[builtins.str] = None,
        profile: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        retry_mode: typing.Optional[builtins.str] = None,
        role_arn: typing.Optional[builtins.str] = None,
        secret_key: typing.Optional[builtins.str] = None,
        session_name: typing.Optional[builtins.str] = None,
        shared_config_files: typing.Optional[typing.Sequence[builtins.str]] = None,
        shared_credentials_file: typing.Optional[builtins.str] = None,
        shared_credentials_files: typing.Optional[typing.Sequence[builtins.str]] = None,
        skip_credentials_validation: typing.Optional[builtins.bool] = None,
        skip_metadata_api_check: typing.Optional[builtins.bool] = None,
        skip_region_validation: typing.Optional[builtins.bool] = None,
        skip_requesting_account_id: typing.Optional[builtins.bool] = None,
        skip_s3_checksum: typing.Optional[builtins.bool] = None,
        sse_customer_key: typing.Optional[builtins.str] = None,
        sts_endpoint: typing.Optional[builtins.str] = None,
        sts_region: typing.Optional[builtins.str] = None,
        token: typing.Optional[builtins.str] = None,
        use_legacy_workflow: typing.Optional[builtins.bool] = None,
        use_path_style: typing.Optional[builtins.bool] = None,
        workspace_key_prefix: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Stores the state as a given key in a given bucket on Amazon S3.

        This backend
        also supports state locking and consistency checking via Dynamo DB, which
        can be enabled by setting the dynamodb_table field to an existing DynamoDB
        table name. A single DynamoDB table can be used to lock multiple remote
        state files. Terraform generates key names that include the values of the
        bucket and key variables.

        Warning! It is highly recommended that you enable Bucket Versioning on the
        S3 bucket to allow for state recovery in the case of accidental deletions
        and human error.

        Read more about this backend in the Terraform docs:
        https://developer.hashicorp.com/terraform/language/settings/backends/s3

        :param bucket: (experimental) Name of the S3 Bucket.
        :param key: (experimental) Path to the state file inside the S3 Bucket. When using a non-default workspace, the state path will be /workspace_key_prefix/workspace_name/key
        :param access_key: (experimental) (Optional) AWS access key. If configured, must also configure secret_key. This can also be sourced from the AWS_ACCESS_KEY_ID environment variable, AWS shared credentials file (e.g. ~/.aws/credentials), or AWS shared configuration file (e.g. ~/.aws/config).
        :param acl: (experimental) (Optional) Canned ACL to be applied to the state file.
        :param allowed_account_ids: (experimental) (Optional) List of allowed AWS account IDs to prevent potential destruction of a live environment. Conflicts with forbidden_account_ids.
        :param assume_role: (experimental) Assuming an IAM Role can be configured in two ways. The preferred way is to use the argument assume_role, the other, which is deprecated, is with arguments at the top level.
        :param assume_role_policy: (deprecated) (Optional) IAM Policy JSON describing further restricting permissions for the IAM Role being assumed.
        :param assume_role_policy_arns: (deprecated) (Optional) Set of Amazon Resource Names (ARNs) of IAM Policies describing further restricting permissions for the IAM Role being assumed.
        :param assume_role_tags: (deprecated) (Optional) Map of assume role session tags.
        :param assume_role_transitive_tag_keys: (deprecated) (Optional) Set of assume role session tag keys to pass to any subsequent sessions.
        :param assume_role_with_web_identity: (experimental) Assume Role With Web Identity Configuration.
        :param custom_ca_bundle: (experimental) (Optional) File containing custom root and intermediate certificates. Can also be set using the AWS_CA_BUNDLE environment variable. Setting ca_bundle in the shared config file is not supported.
        :param dynamodb_endpoint: (deprecated) (Optional) Custom endpoint for the AWS DynamoDB API. This can also be sourced from the AWS_DYNAMODB_ENDPOINT environment variable.
        :param dynamodb_table: (experimental) (Optional) Name of DynamoDB Table to use for state locking and consistency. The table must have a partition key named LockID with type of String. If not configured, state locking will be disabled.
        :param ec2_metadata_service_endpoint: (experimental) Optional) Custom endpoint URL for the EC2 Instance Metadata Service (IMDS) API. Can also be set with the AWS_EC2_METADATA_SERVICE_ENDPOINT environment variable.
        :param ec2_metadata_service_endpoint_mode: (experimental) (Optional) Mode to use in communicating with the metadata service. Valid values are IPv4 and IPv6. Can also be set with the AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE environment variable.
        :param encrypt: (experimental) (Optional) Enable server side encryption of the state file.
        :param endpoint: (deprecated) (Optional) Custom endpoint for the AWS S3 API. This can also be sourced from the AWS_S3_ENDPOINT environment variable.
        :param endpoints: (experimental) (Optional) The endpoint configuration block.
        :param external_id: (deprecated) (Optional) External identifier to use when assuming the role.
        :param forbidden_account_ids: (experimental) (Optional) List of forbidden AWS account IDs to prevent potential destruction of a live environment. Conflicts with allowed_account_ids.
        :param force_path_style: (deprecated) (Optional) Enable path-style S3 URLs (https:/// instead of https://.).
        :param http_proxy: (experimental) (Optional) URL of a proxy to use for HTTP requests when accessing the AWS API. Can also be set using the HTTP_PROXY or http_proxy environment variables.
        :param https_proxy: (experimental) (Optional) URL of a proxy to use for HTTPS requests when accessing the AWS API. Can also be set using the HTTPS_PROXY or https_proxy environment variables.
        :param iam_endpoint: (deprecated) (Optional) Custom endpoint for the AWS Identity and Access Management (IAM) API. This can also be sourced from the AWS_IAM_ENDPOINT environment variable.
        :param insecure: (experimental) Optional) Whether to explicitly allow the backend to perform "insecure" SSL requests. If omitted, the default value is false.
        :param kms_key_id: (experimental) (Optional) Amazon Resource Name (ARN) of a Key Management Service (KMS) Key to use for encrypting the state. Note that if this value is specified, Terraform will need kms:Encrypt, kms:Decrypt and kms:GenerateDataKey permissions on this KMS key.
        :param max_retries: (experimental) (Optional) The maximum number of times an AWS API request is retried on retryable failure. Defaults to 5.
        :param no_proxy: (experimental) (Optional) Comma-separated list of hosts that should not use HTTP or HTTPS proxies. Each value can be one of: - A domain name - An IP address - A CIDR address - An asterisk (*), to indicate that no proxying should be performed Domain name and IP address values can also include a port number. Can also be set using the NO_PROXY or no_proxy environment variables.
        :param profile: (experimental) (Optional) Name of AWS profile in AWS shared credentials file (e.g. ~/.aws/credentials) or AWS shared configuration file (e.g. ~/.aws/config) to use for credentials and/or configuration. This can also be sourced from the AWS_PROFILE environment variable.
        :param region: (experimental) AWS Region of the S3 Bucket and DynamoDB Table (if used). This can also be sourced from the AWS_DEFAULT_REGION and AWS_REGION environment variables.
        :param retry_mode: (experimental) (Optional) Specifies how retries are attempted. Valid values are standard and adaptive. Can also be configured using the AWS_RETRY_MODE environment variable or the shared config file parameter retry_mode.
        :param role_arn: (deprecated) (Optional) Amazon Resource Name (ARN) of the IAM Role to assume.
        :param secret_key: (experimental) (Optional) AWS secret access key. If configured, must also configure access_key. This can also be sourced from the AWS_SECRET_ACCESS_KEY environment variable, AWS shared credentials file (e.g. ~/.aws/credentials), or AWS shared configuration file (e.g. ~/.aws/config)
        :param session_name: (deprecated) (Optional) Session name to use when assuming the role.
        :param shared_config_files: (experimental) (Optional) List of paths to AWS shared configuration files. Defaults to ~/.aws/config.
        :param shared_credentials_file: (experimental) (Optional) Path to the AWS shared credentials file. Defaults to ~/.aws/credentials.
        :param shared_credentials_files: (experimental) (Optional) List of paths to AWS shared credentials files. Defaults to ~/.aws/credentials.
        :param skip_credentials_validation: (experimental) (Optional) Skip credentials validation via the STS API.
        :param skip_metadata_api_check: (experimental) (Optional) Skip usage of EC2 Metadata API.
        :param skip_region_validation: (experimental) (Optional) Skip validation of provided region name.
        :param skip_requesting_account_id: (experimental) (Optional) Whether to skip requesting the account ID. Useful for AWS API implementations that do not have the IAM, STS API, or metadata API.
        :param skip_s3_checksum: (experimental) (Optional) Do not include checksum when uploading S3 Objects. Useful for some S3-Compatible APIs.
        :param sse_customer_key: (experimental) (Optional) The key to use for encrypting state with Server-Side Encryption with Customer-Provided Keys (SSE-C). This is the base64-encoded value of the key, which must decode to 256 bits. This can also be sourced from the AWS_SSE_CUSTOMER_KEY environment variable, which is recommended due to the sensitivity of the value. Setting it inside a terraform file will cause it to be persisted to disk in terraform.tfstate.
        :param sts_endpoint: (deprecated) (Optional) Custom endpoint for the AWS Security Token Service (STS) API. This can also be sourced from the AWS_STS_ENDPOINT environment variable.
        :param sts_region: (experimental) (Optional) AWS region for STS. If unset, AWS will use the same region for STS as other non-STS operations.
        :param token: (experimental) (Optional) Multi-Factor Authentication (MFA) token. This can also be sourced from the AWS_SESSION_TOKEN environment variable.
        :param use_legacy_workflow: (experimental) (Optional) Use the legacy authentication workflow, preferring environment variables over backend configuration. Defaults to true. This behavior does not align with the authentication flow of the AWS CLI or SDK's, and will be removed in the future.
        :param use_path_style: (experimental) (Optional) Enable path-style S3 URLs (https:/// instead of https://.).
        :param workspace_key_prefix: (experimental) (Optional) Prefix applied to the state path inside the bucket. This is only relevant when using a non-default workspace. Defaults to env:

        :stability: experimental
        '''
        if isinstance(assume_role, dict):
            assume_role = S3BackendAssumeRoleConfig(**assume_role)
        if isinstance(assume_role_with_web_identity, dict):
            assume_role_with_web_identity = S3BackendAssumeRoleWithWebIdentityConfig(**assume_role_with_web_identity)
        if isinstance(endpoints, dict):
            endpoints = S3BackendEndpointConfig(**endpoints)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9aec09d69e709cce0e4c77ccc2be547a1cfcf4aa8a006a9192483c7aee5b156d)
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
            check_type(argname="argument access_key", value=access_key, expected_type=type_hints["access_key"])
            check_type(argname="argument acl", value=acl, expected_type=type_hints["acl"])
            check_type(argname="argument allowed_account_ids", value=allowed_account_ids, expected_type=type_hints["allowed_account_ids"])
            check_type(argname="argument assume_role", value=assume_role, expected_type=type_hints["assume_role"])
            check_type(argname="argument assume_role_policy", value=assume_role_policy, expected_type=type_hints["assume_role_policy"])
            check_type(argname="argument assume_role_policy_arns", value=assume_role_policy_arns, expected_type=type_hints["assume_role_policy_arns"])
            check_type(argname="argument assume_role_tags", value=assume_role_tags, expected_type=type_hints["assume_role_tags"])
            check_type(argname="argument assume_role_transitive_tag_keys", value=assume_role_transitive_tag_keys, expected_type=type_hints["assume_role_transitive_tag_keys"])
            check_type(argname="argument assume_role_with_web_identity", value=assume_role_with_web_identity, expected_type=type_hints["assume_role_with_web_identity"])
            check_type(argname="argument custom_ca_bundle", value=custom_ca_bundle, expected_type=type_hints["custom_ca_bundle"])
            check_type(argname="argument dynamodb_endpoint", value=dynamodb_endpoint, expected_type=type_hints["dynamodb_endpoint"])
            check_type(argname="argument dynamodb_table", value=dynamodb_table, expected_type=type_hints["dynamodb_table"])
            check_type(argname="argument ec2_metadata_service_endpoint", value=ec2_metadata_service_endpoint, expected_type=type_hints["ec2_metadata_service_endpoint"])
            check_type(argname="argument ec2_metadata_service_endpoint_mode", value=ec2_metadata_service_endpoint_mode, expected_type=type_hints["ec2_metadata_service_endpoint_mode"])
            check_type(argname="argument encrypt", value=encrypt, expected_type=type_hints["encrypt"])
            check_type(argname="argument endpoint", value=endpoint, expected_type=type_hints["endpoint"])
            check_type(argname="argument endpoints", value=endpoints, expected_type=type_hints["endpoints"])
            check_type(argname="argument external_id", value=external_id, expected_type=type_hints["external_id"])
            check_type(argname="argument forbidden_account_ids", value=forbidden_account_ids, expected_type=type_hints["forbidden_account_ids"])
            check_type(argname="argument force_path_style", value=force_path_style, expected_type=type_hints["force_path_style"])
            check_type(argname="argument http_proxy", value=http_proxy, expected_type=type_hints["http_proxy"])
            check_type(argname="argument https_proxy", value=https_proxy, expected_type=type_hints["https_proxy"])
            check_type(argname="argument iam_endpoint", value=iam_endpoint, expected_type=type_hints["iam_endpoint"])
            check_type(argname="argument insecure", value=insecure, expected_type=type_hints["insecure"])
            check_type(argname="argument kms_key_id", value=kms_key_id, expected_type=type_hints["kms_key_id"])
            check_type(argname="argument max_retries", value=max_retries, expected_type=type_hints["max_retries"])
            check_type(argname="argument no_proxy", value=no_proxy, expected_type=type_hints["no_proxy"])
            check_type(argname="argument profile", value=profile, expected_type=type_hints["profile"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument retry_mode", value=retry_mode, expected_type=type_hints["retry_mode"])
            check_type(argname="argument role_arn", value=role_arn, expected_type=type_hints["role_arn"])
            check_type(argname="argument secret_key", value=secret_key, expected_type=type_hints["secret_key"])
            check_type(argname="argument session_name", value=session_name, expected_type=type_hints["session_name"])
            check_type(argname="argument shared_config_files", value=shared_config_files, expected_type=type_hints["shared_config_files"])
            check_type(argname="argument shared_credentials_file", value=shared_credentials_file, expected_type=type_hints["shared_credentials_file"])
            check_type(argname="argument shared_credentials_files", value=shared_credentials_files, expected_type=type_hints["shared_credentials_files"])
            check_type(argname="argument skip_credentials_validation", value=skip_credentials_validation, expected_type=type_hints["skip_credentials_validation"])
            check_type(argname="argument skip_metadata_api_check", value=skip_metadata_api_check, expected_type=type_hints["skip_metadata_api_check"])
            check_type(argname="argument skip_region_validation", value=skip_region_validation, expected_type=type_hints["skip_region_validation"])
            check_type(argname="argument skip_requesting_account_id", value=skip_requesting_account_id, expected_type=type_hints["skip_requesting_account_id"])
            check_type(argname="argument skip_s3_checksum", value=skip_s3_checksum, expected_type=type_hints["skip_s3_checksum"])
            check_type(argname="argument sse_customer_key", value=sse_customer_key, expected_type=type_hints["sse_customer_key"])
            check_type(argname="argument sts_endpoint", value=sts_endpoint, expected_type=type_hints["sts_endpoint"])
            check_type(argname="argument sts_region", value=sts_region, expected_type=type_hints["sts_region"])
            check_type(argname="argument token", value=token, expected_type=type_hints["token"])
            check_type(argname="argument use_legacy_workflow", value=use_legacy_workflow, expected_type=type_hints["use_legacy_workflow"])
            check_type(argname="argument use_path_style", value=use_path_style, expected_type=type_hints["use_path_style"])
            check_type(argname="argument workspace_key_prefix", value=workspace_key_prefix, expected_type=type_hints["workspace_key_prefix"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bucket": bucket,
            "key": key,
        }
        if access_key is not None:
            self._values["access_key"] = access_key
        if acl is not None:
            self._values["acl"] = acl
        if allowed_account_ids is not None:
            self._values["allowed_account_ids"] = allowed_account_ids
        if assume_role is not None:
            self._values["assume_role"] = assume_role
        if assume_role_policy is not None:
            self._values["assume_role_policy"] = assume_role_policy
        if assume_role_policy_arns is not None:
            self._values["assume_role_policy_arns"] = assume_role_policy_arns
        if assume_role_tags is not None:
            self._values["assume_role_tags"] = assume_role_tags
        if assume_role_transitive_tag_keys is not None:
            self._values["assume_role_transitive_tag_keys"] = assume_role_transitive_tag_keys
        if assume_role_with_web_identity is not None:
            self._values["assume_role_with_web_identity"] = assume_role_with_web_identity
        if custom_ca_bundle is not None:
            self._values["custom_ca_bundle"] = custom_ca_bundle
        if dynamodb_endpoint is not None:
            self._values["dynamodb_endpoint"] = dynamodb_endpoint
        if dynamodb_table is not None:
            self._values["dynamodb_table"] = dynamodb_table
        if ec2_metadata_service_endpoint is not None:
            self._values["ec2_metadata_service_endpoint"] = ec2_metadata_service_endpoint
        if ec2_metadata_service_endpoint_mode is not None:
            self._values["ec2_metadata_service_endpoint_mode"] = ec2_metadata_service_endpoint_mode
        if encrypt is not None:
            self._values["encrypt"] = encrypt
        if endpoint is not None:
            self._values["endpoint"] = endpoint
        if endpoints is not None:
            self._values["endpoints"] = endpoints
        if external_id is not None:
            self._values["external_id"] = external_id
        if forbidden_account_ids is not None:
            self._values["forbidden_account_ids"] = forbidden_account_ids
        if force_path_style is not None:
            self._values["force_path_style"] = force_path_style
        if http_proxy is not None:
            self._values["http_proxy"] = http_proxy
        if https_proxy is not None:
            self._values["https_proxy"] = https_proxy
        if iam_endpoint is not None:
            self._values["iam_endpoint"] = iam_endpoint
        if insecure is not None:
            self._values["insecure"] = insecure
        if kms_key_id is not None:
            self._values["kms_key_id"] = kms_key_id
        if max_retries is not None:
            self._values["max_retries"] = max_retries
        if no_proxy is not None:
            self._values["no_proxy"] = no_proxy
        if profile is not None:
            self._values["profile"] = profile
        if region is not None:
            self._values["region"] = region
        if retry_mode is not None:
            self._values["retry_mode"] = retry_mode
        if role_arn is not None:
            self._values["role_arn"] = role_arn
        if secret_key is not None:
            self._values["secret_key"] = secret_key
        if session_name is not None:
            self._values["session_name"] = session_name
        if shared_config_files is not None:
            self._values["shared_config_files"] = shared_config_files
        if shared_credentials_file is not None:
            self._values["shared_credentials_file"] = shared_credentials_file
        if shared_credentials_files is not None:
            self._values["shared_credentials_files"] = shared_credentials_files
        if skip_credentials_validation is not None:
            self._values["skip_credentials_validation"] = skip_credentials_validation
        if skip_metadata_api_check is not None:
            self._values["skip_metadata_api_check"] = skip_metadata_api_check
        if skip_region_validation is not None:
            self._values["skip_region_validation"] = skip_region_validation
        if skip_requesting_account_id is not None:
            self._values["skip_requesting_account_id"] = skip_requesting_account_id
        if skip_s3_checksum is not None:
            self._values["skip_s3_checksum"] = skip_s3_checksum
        if sse_customer_key is not None:
            self._values["sse_customer_key"] = sse_customer_key
        if sts_endpoint is not None:
            self._values["sts_endpoint"] = sts_endpoint
        if sts_region is not None:
            self._values["sts_region"] = sts_region
        if token is not None:
            self._values["token"] = token
        if use_legacy_workflow is not None:
            self._values["use_legacy_workflow"] = use_legacy_workflow
        if use_path_style is not None:
            self._values["use_path_style"] = use_path_style
        if workspace_key_prefix is not None:
            self._values["workspace_key_prefix"] = workspace_key_prefix

    @builtins.property
    def bucket(self) -> builtins.str:
        '''(experimental) Name of the S3 Bucket.

        :stability: experimental
        '''
        result = self._values.get("bucket")
        assert result is not None, "Required property 'bucket' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def key(self) -> builtins.str:
        '''(experimental) Path to the state file inside the S3 Bucket.

        When using a non-default workspace, the state path will be /workspace_key_prefix/workspace_name/key

        :stability: experimental
        '''
        result = self._values.get("key")
        assert result is not None, "Required property 'key' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def access_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) AWS access key.

        If configured, must also configure secret_key.
        This can also be sourced from
        the AWS_ACCESS_KEY_ID environment variable,
        AWS shared credentials file (e.g. ~/.aws/credentials),
        or AWS shared configuration file (e.g. ~/.aws/config).

        :stability: experimental
        '''
        result = self._values.get("access_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def acl(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Canned ACL to be applied to the state file.

        :stability: experimental
        '''
        result = self._values.get("acl")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def allowed_account_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) (Optional) List of allowed AWS account IDs to prevent potential destruction of a live environment.

        Conflicts with forbidden_account_ids.

        :stability: experimental
        '''
        result = self._values.get("allowed_account_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def assume_role(self) -> typing.Optional[S3BackendAssumeRoleConfig]:
        '''(experimental) Assuming an IAM Role can be configured in two ways.

        The preferred way is to use the argument assume_role, the other, which is deprecated, is with arguments at the top level.

        :stability: experimental
        '''
        result = self._values.get("assume_role")
        return typing.cast(typing.Optional[S3BackendAssumeRoleConfig], result)

    @builtins.property
    def assume_role_policy(self) -> typing.Optional[builtins.str]:
        '''(deprecated) (Optional) IAM Policy JSON describing further restricting permissions for the IAM Role being assumed.

        :deprecated: Use assumeRole.policy instead.

        :stability: deprecated
        '''
        result = self._values.get("assume_role_policy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def assume_role_policy_arns(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(deprecated) (Optional) Set of Amazon Resource Names (ARNs) of IAM Policies describing further restricting permissions for the IAM Role being assumed.

        :deprecated: Use assumeRole.policyArns instead.

        :stability: deprecated
        '''
        result = self._values.get("assume_role_policy_arns")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def assume_role_tags(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        '''(deprecated) (Optional) Map of assume role session tags.

        :deprecated: Use assumeRole.tags instead.

        :stability: deprecated
        '''
        result = self._values.get("assume_role_tags")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    @builtins.property
    def assume_role_transitive_tag_keys(
        self,
    ) -> typing.Optional[typing.List[builtins.str]]:
        '''(deprecated) (Optional) Set of assume role session tag keys to pass to any subsequent sessions.

        :deprecated: Use assumeRole.transitiveTagKeys instead.

        :stability: deprecated
        '''
        result = self._values.get("assume_role_transitive_tag_keys")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def assume_role_with_web_identity(
        self,
    ) -> typing.Optional[S3BackendAssumeRoleWithWebIdentityConfig]:
        '''(experimental) Assume Role With Web Identity Configuration.

        :stability: experimental
        '''
        result = self._values.get("assume_role_with_web_identity")
        return typing.cast(typing.Optional[S3BackendAssumeRoleWithWebIdentityConfig], result)

    @builtins.property
    def custom_ca_bundle(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) File containing custom root and intermediate certificates.

        Can also be set using the AWS_CA_BUNDLE environment variable.
        Setting ca_bundle in the shared config file is not supported.

        :stability: experimental
        '''
        result = self._values.get("custom_ca_bundle")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def dynamodb_endpoint(self) -> typing.Optional[builtins.str]:
        '''(deprecated) (Optional) Custom endpoint for the AWS DynamoDB API.

        This can also be sourced from the AWS_DYNAMODB_ENDPOINT environment variable.

        :deprecated: Use endpoints.dynamodb instead

        :stability: deprecated
        '''
        result = self._values.get("dynamodb_endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def dynamodb_table(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Name of DynamoDB Table to use for state locking and consistency.

        The table must have a partition key named LockID with type of String.
        If not configured, state locking will be disabled.

        :stability: experimental
        '''
        result = self._values.get("dynamodb_table")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ec2_metadata_service_endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) Optional) Custom endpoint URL for the EC2 Instance Metadata Service (IMDS) API.

        Can also be set with the AWS_EC2_METADATA_SERVICE_ENDPOINT environment variable.

        :stability: experimental
        '''
        result = self._values.get("ec2_metadata_service_endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ec2_metadata_service_endpoint_mode(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Mode to use in communicating with the metadata service.

        Valid values are IPv4 and IPv6.
        Can also be set with the AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE environment variable.

        :stability: experimental
        '''
        result = self._values.get("ec2_metadata_service_endpoint_mode")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def encrypt(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Enable server side encryption of the state file.

        :stability: experimental
        '''
        result = self._values.get("encrypt")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def endpoint(self) -> typing.Optional[builtins.str]:
        '''(deprecated) (Optional) Custom endpoint for the AWS S3 API.

        This can also be sourced from the AWS_S3_ENDPOINT environment variable.

        :deprecated: Use endpoints.s3 instead

        :stability: deprecated
        '''
        result = self._values.get("endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def endpoints(self) -> typing.Optional["S3BackendEndpointConfig"]:
        '''(experimental) (Optional) The endpoint configuration block.

        :stability: experimental
        '''
        result = self._values.get("endpoints")
        return typing.cast(typing.Optional["S3BackendEndpointConfig"], result)

    @builtins.property
    def external_id(self) -> typing.Optional[builtins.str]:
        '''(deprecated) (Optional) External identifier to use when assuming the role.

        :deprecated: Use assume_role.external_id instead.

        :stability: deprecated
        '''
        result = self._values.get("external_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def forbidden_account_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) (Optional) List of forbidden AWS account IDs to prevent potential destruction of a live environment.

        Conflicts with allowed_account_ids.

        :stability: experimental
        '''
        result = self._values.get("forbidden_account_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def force_path_style(self) -> typing.Optional[builtins.bool]:
        '''(deprecated) (Optional) Enable path-style S3 URLs (https:/// instead of https://.).

        :deprecated: Use usePathStyle instead

        :stability: deprecated
        '''
        result = self._values.get("force_path_style")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def http_proxy(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) URL of a proxy to use for HTTP requests when accessing the AWS API.

        Can also be set using the HTTP_PROXY or http_proxy environment variables.

        :stability: experimental
        '''
        result = self._values.get("http_proxy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def https_proxy(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) URL of a proxy to use for HTTPS requests when accessing the AWS API.

        Can also be set using the HTTPS_PROXY or https_proxy environment variables.

        :stability: experimental
        '''
        result = self._values.get("https_proxy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def iam_endpoint(self) -> typing.Optional[builtins.str]:
        '''(deprecated) (Optional) Custom endpoint for the AWS Identity and Access Management (IAM) API.

        This can also be sourced from the AWS_IAM_ENDPOINT environment variable.

        :deprecated: Use endpoints.iam instead

        :stability: deprecated
        '''
        result = self._values.get("iam_endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def insecure(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Optional) Whether to explicitly allow the backend to perform "insecure" SSL requests.

        If omitted, the default value is false.

        :stability: experimental
        '''
        result = self._values.get("insecure")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def kms_key_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Amazon Resource Name (ARN) of a Key Management Service (KMS) Key to use for encrypting the state.

        Note that if this value is specified,
        Terraform will need kms:Encrypt, kms:Decrypt and kms:GenerateDataKey permissions on this KMS key.

        :stability: experimental
        '''
        result = self._values.get("kms_key_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def max_retries(self) -> typing.Optional[jsii.Number]:
        '''(experimental) (Optional) The maximum number of times an AWS API request is retried on retryable failure.

        Defaults to 5.

        :stability: experimental
        '''
        result = self._values.get("max_retries")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def no_proxy(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Comma-separated list of hosts that should not use HTTP or HTTPS proxies.

        Each value can be one of:

        - A domain name
        - An IP address
        - A CIDR address
        - An asterisk (*), to indicate that no proxying should be performed Domain name and IP address values can also include a port number.
          Can also be set using the NO_PROXY or no_proxy environment variables.

        :stability: experimental
        '''
        result = self._values.get("no_proxy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def profile(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Name of AWS profile in AWS shared credentials file (e.g. ~/.aws/credentials) or AWS shared configuration file (e.g. ~/.aws/config) to use for credentials and/or configuration. This can also be sourced from the AWS_PROFILE environment variable.

        :stability: experimental
        '''
        result = self._values.get("profile")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) AWS Region of the S3 Bucket and DynamoDB Table (if used).

        This can also
        be sourced from the AWS_DEFAULT_REGION and AWS_REGION environment
        variables.

        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def retry_mode(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Specifies how retries are attempted.

        Valid values are standard and adaptive.
        Can also be configured using the AWS_RETRY_MODE environment variable or the shared config file parameter retry_mode.

        :stability: experimental
        '''
        result = self._values.get("retry_mode")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def role_arn(self) -> typing.Optional[builtins.str]:
        '''(deprecated) (Optional) Amazon Resource Name (ARN) of the IAM Role to assume.

        :deprecated: Use assumeRole.roleArn instead.

        :stability: deprecated
        '''
        result = self._values.get("role_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def secret_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) AWS secret access key.

        If configured, must also configure access_key.
        This can also be sourced from
        the AWS_SECRET_ACCESS_KEY environment variable,
        AWS shared credentials file (e.g. ~/.aws/credentials),
        or AWS shared configuration file (e.g. ~/.aws/config)

        :stability: experimental
        '''
        result = self._values.get("secret_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def session_name(self) -> typing.Optional[builtins.str]:
        '''(deprecated) (Optional) Session name to use when assuming the role.

        :deprecated: Use assumeRole.sessionName instead.

        :stability: deprecated
        '''
        result = self._values.get("session_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def shared_config_files(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) (Optional) List of paths to AWS shared configuration files.

        Defaults to ~/.aws/config.

        :stability: experimental
        '''
        result = self._values.get("shared_config_files")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def shared_credentials_file(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Path to the AWS shared credentials file.

        Defaults to ~/.aws/credentials.

        :stability: experimental
        '''
        result = self._values.get("shared_credentials_file")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def shared_credentials_files(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) (Optional) List of paths to AWS shared credentials files.

        Defaults to ~/.aws/credentials.

        :stability: experimental
        '''
        result = self._values.get("shared_credentials_files")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def skip_credentials_validation(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Skip credentials validation via the STS API.

        :stability: experimental
        '''
        result = self._values.get("skip_credentials_validation")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def skip_metadata_api_check(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Skip usage of EC2 Metadata API.

        :stability: experimental
        '''
        result = self._values.get("skip_metadata_api_check")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def skip_region_validation(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Skip validation of provided region name.

        :stability: experimental
        '''
        result = self._values.get("skip_region_validation")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def skip_requesting_account_id(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Whether to skip requesting the account ID.

        Useful for AWS API implementations that do not have the IAM, STS API, or metadata API.

        :stability: experimental
        '''
        result = self._values.get("skip_requesting_account_id")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def skip_s3_checksum(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Do not include checksum when uploading S3 Objects.

        Useful for some S3-Compatible APIs.

        :stability: experimental
        '''
        result = self._values.get("skip_s3_checksum")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def sse_customer_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The key to use for encrypting state with Server-Side Encryption with Customer-Provided Keys (SSE-C).

        This is the base64-encoded value of the key, which must decode to 256 bits.
        This can also be sourced from the AWS_SSE_CUSTOMER_KEY environment variable,
        which is recommended due to the sensitivity of the value.
        Setting it inside a terraform file will cause it to be persisted to disk in terraform.tfstate.

        :stability: experimental
        '''
        result = self._values.get("sse_customer_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sts_endpoint(self) -> typing.Optional[builtins.str]:
        '''(deprecated) (Optional) Custom endpoint for the AWS Security Token Service (STS) API.

        This can also be sourced from the AWS_STS_ENDPOINT environment variable.

        :deprecated: Use endpoints.sts instead

        :stability: deprecated
        '''
        result = self._values.get("sts_endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sts_region(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) AWS region for STS.

        If unset, AWS will use the same region for STS as other non-STS operations.

        :stability: experimental
        '''
        result = self._values.get("sts_region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def token(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Multi-Factor Authentication (MFA) token.

        This can also be sourced from the AWS_SESSION_TOKEN environment variable.

        :stability: experimental
        '''
        result = self._values.get("token")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def use_legacy_workflow(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Use the legacy authentication workflow, preferring environment variables over backend configuration.

        Defaults to true.
        This behavior does not align with the authentication flow of the AWS CLI or SDK's, and will be removed in the future.

        :stability: experimental
        '''
        result = self._values.get("use_legacy_workflow")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_path_style(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Enable path-style S3 URLs (https:/// instead of https://.).

        :stability: experimental
        '''
        result = self._values.get("use_path_style")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def workspace_key_prefix(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Prefix applied to the state path inside the bucket.

        This is only relevant when using a non-default workspace. Defaults to env:

        :stability: experimental
        '''
        result = self._values.get("workspace_key_prefix")
        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 "S3BackendConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.S3BackendEndpointConfig",
    jsii_struct_bases=[],
    name_mapping={
        "dynamodb": "dynamodb",
        "iam": "iam",
        "s3": "s3",
        "sso": "sso",
        "sts": "sts",
    },
)
class S3BackendEndpointConfig:
    def __init__(
        self,
        *,
        dynamodb: typing.Optional[builtins.str] = None,
        iam: typing.Optional[builtins.str] = None,
        s3: typing.Optional[builtins.str] = None,
        sso: typing.Optional[builtins.str] = None,
        sts: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param dynamodb: (experimental) (Optional) Custom endpoint URL for the AWS DynamoDB API. This can also be sourced from the environment variable AWS_ENDPOINT_URL_DYNAMODB or the deprecated environment variable AWS_DYNAMODB_ENDPOINT.
        :param iam: (experimental) (Optional) Custom endpoint URL for the AWS IAM API. This can also be sourced from the environment variable AWS_ENDPOINT_URL_IAM or the deprecated environment variable AWS_IAM_ENDPOINT.
        :param s3: (experimental) (Optional) Custom endpoint URL for the AWS S3 API. This can also be sourced from the environment variable AWS_ENDPOINT_URL_S3 or the deprecated environment variable AWS_S3_ENDPOINT.
        :param sso: (experimental) (Optional) Custom endpoint URL for the AWS IAM Identity Center (formerly known as AWS SSO) API. This can also be sourced from the environment variable AWS_ENDPOINT_URL_SSO.
        :param sts: (experimental) (Optional) Custom endpoint URL for the AWS STS API. This can also be sourced from the environment variable AWS_ENDPOINT_URL_STS or the deprecated environment variable AWS_STS_ENDPOINT.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e0fb31f7971cd3bc9a1dff3639c8c469c26120ff2ae90196d3757b79ed5d4e7c)
            check_type(argname="argument dynamodb", value=dynamodb, expected_type=type_hints["dynamodb"])
            check_type(argname="argument iam", value=iam, expected_type=type_hints["iam"])
            check_type(argname="argument s3", value=s3, expected_type=type_hints["s3"])
            check_type(argname="argument sso", value=sso, expected_type=type_hints["sso"])
            check_type(argname="argument sts", value=sts, expected_type=type_hints["sts"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if dynamodb is not None:
            self._values["dynamodb"] = dynamodb
        if iam is not None:
            self._values["iam"] = iam
        if s3 is not None:
            self._values["s3"] = s3
        if sso is not None:
            self._values["sso"] = sso
        if sts is not None:
            self._values["sts"] = sts

    @builtins.property
    def dynamodb(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Custom endpoint URL for the AWS DynamoDB API.

        This can also be sourced from the environment variable AWS_ENDPOINT_URL_DYNAMODB or the deprecated environment variable AWS_DYNAMODB_ENDPOINT.

        :stability: experimental
        '''
        result = self._values.get("dynamodb")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def iam(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Custom endpoint URL for the AWS IAM API.

        This can also be sourced from the environment variable AWS_ENDPOINT_URL_IAM or the deprecated environment variable AWS_IAM_ENDPOINT.

        :stability: experimental
        '''
        result = self._values.get("iam")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def s3(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Custom endpoint URL for the AWS S3 API.

        This can also be sourced from the environment variable AWS_ENDPOINT_URL_S3 or the deprecated environment variable AWS_S3_ENDPOINT.

        :stability: experimental
        '''
        result = self._values.get("s3")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sso(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Custom endpoint URL for the AWS IAM Identity Center (formerly known as AWS SSO) API.

        This can also be sourced from the environment variable AWS_ENDPOINT_URL_SSO.

        :stability: experimental
        '''
        result = self._values.get("sso")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sts(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Custom endpoint URL for the AWS STS API.

        This can also be sourced from the environment variable AWS_ENDPOINT_URL_STS or the deprecated environment variable AWS_STS_ENDPOINT.

        :stability: experimental
        '''
        result = self._values.get("sts")
        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 "S3BackendEndpointConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.SSHProvisionerConnection",
    jsii_struct_bases=[],
    name_mapping={
        "host": "host",
        "type": "type",
        "agent": "agent",
        "agent_identity": "agentIdentity",
        "bastion_certificate": "bastionCertificate",
        "bastion_host": "bastionHost",
        "bastion_host_key": "bastionHostKey",
        "bastion_password": "bastionPassword",
        "bastion_port": "bastionPort",
        "bastion_private_key": "bastionPrivateKey",
        "bastion_user": "bastionUser",
        "certificate": "certificate",
        "host_key": "hostKey",
        "password": "password",
        "port": "port",
        "private_key": "privateKey",
        "proxy_host": "proxyHost",
        "proxy_port": "proxyPort",
        "proxy_scheme": "proxyScheme",
        "proxy_user_name": "proxyUserName",
        "proxy_user_password": "proxyUserPassword",
        "script_path": "scriptPath",
        "target_platform": "targetPlatform",
        "timeout": "timeout",
        "user": "user",
    },
)
class SSHProvisionerConnection:
    def __init__(
        self,
        *,
        host: builtins.str,
        type: builtins.str,
        agent: typing.Optional[builtins.str] = None,
        agent_identity: typing.Optional[builtins.str] = None,
        bastion_certificate: typing.Optional[builtins.str] = None,
        bastion_host: typing.Optional[builtins.str] = None,
        bastion_host_key: typing.Optional[builtins.str] = None,
        bastion_password: typing.Optional[builtins.str] = None,
        bastion_port: typing.Optional[jsii.Number] = None,
        bastion_private_key: typing.Optional[builtins.str] = None,
        bastion_user: typing.Optional[builtins.str] = None,
        certificate: typing.Optional[builtins.str] = None,
        host_key: typing.Optional[builtins.str] = None,
        password: typing.Optional[builtins.str] = None,
        port: typing.Optional[jsii.Number] = None,
        private_key: typing.Optional[builtins.str] = None,
        proxy_host: typing.Optional[builtins.str] = None,
        proxy_port: typing.Optional[jsii.Number] = None,
        proxy_scheme: typing.Optional[builtins.str] = None,
        proxy_user_name: typing.Optional[builtins.str] = None,
        proxy_user_password: typing.Optional[builtins.str] = None,
        script_path: typing.Optional[builtins.str] = None,
        target_platform: typing.Optional[builtins.str] = None,
        timeout: typing.Optional[builtins.str] = None,
        user: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Most provisioners require access to the remote resource via SSH or WinRM and expect a nested connection block with details about how to connect.

        Refer to {@link https://developer.hashicorp.com/terraform/language/resources/provisioners/connection connection}

        :param host: (experimental) The address of the resource to connect to.
        :param type: (experimental) The connection type. Valid values are "ssh" and "winrm". Provisioners typically assume that the remote system runs Microsoft Windows when using WinRM. Behaviors based on the SSH target_platform will force Windows-specific behavior for WinRM, unless otherwise specified.
        :param agent: (experimental) Set to false to disable using ssh-agent to authenticate. On Windows the only supported SSH authentication agent is Pageant.
        :param agent_identity: (experimental) The preferred identity from the ssh agent for authentication.
        :param bastion_certificate: (experimental) The contents of a signed CA Certificate. The certificate argument must be used in conjunction with a bastion_private_key. These can be loaded from a file on disk using the the file function.
        :param bastion_host: (experimental) Setting this enables the bastion Host connection. The provisioner will connect to bastion_host first, and then connect from there to host.
        :param bastion_host_key: (experimental) The public key from the remote host or the signing CA, used to verify the host connection.
        :param bastion_password: (experimental) The password to use for the bastion host.
        :param bastion_port: (experimental) The port to use connect to the bastion host.
        :param bastion_private_key: (experimental) The contents of an SSH key file to use for the bastion host. These can be loaded from a file on disk using the file function.
        :param bastion_user: (experimental) The user for the connection to the bastion host.
        :param certificate: (experimental) The contents of a signed CA Certificate. The certificate argument must be used in conjunction with a private_key. These can be loaded from a file on disk using the the file function.
        :param host_key: (experimental) The public key from the remote host or the signing CA, used to verify the connection.
        :param password: (experimental) The password to use for the connection.
        :param port: (experimental) The port to connect to. Default: 22
        :param private_key: (experimental) The contents of an SSH key to use for the connection. These can be loaded from a file on disk using the file function. This takes preference over password if provided.
        :param proxy_host: (experimental) Setting this enables the SSH over HTTP connection. This host will be connected to first, and then the host or bastion_host connection will be made from there.
        :param proxy_port: (experimental) The port to use connect to the proxy host.
        :param proxy_scheme: (experimental) The ssh connection also supports the following fields to facilitate connections by SSH over HTTP proxy.
        :param proxy_user_name: (experimental) The username to use connect to the private proxy host. This argument should be specified only if authentication is required for the HTTP Proxy server.
        :param proxy_user_password: (experimental) The password to use connect to the private proxy host. This argument should be specified only if authentication is required for the HTTP Proxy server.
        :param script_path: (experimental) The path used to copy scripts meant for remote execution. Refer to {@link https://developer.hashicorp.com/terraform/language/resources/provisioners/connection#how-provisioners-execute-remote-scripts How Provisioners Execute Remote Scripts below for more details}
        :param target_platform: (experimental) The target platform to connect to. Valid values are "windows" and "unix". If the platform is set to windows, the default script_path is c:\\windows\\temp\\terraform_%RAND%.cmd, assuming the SSH default shell is cmd.exe. If the SSH default shell is PowerShell, set script_path to "c:/windows/temp/terraform_%RAND%.ps1" Default: unix
        :param timeout: (experimental) The timeout to wait for the connection to become available. Should be provided as a string (e.g., "30s" or "5m".) Default: 5m
        :param user: (experimental) The user to use for the connection. Default: root

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1fb2f364aa0cd0cb0a71478e84ca35029f533391f3edcf2a9bee5c8b23be16d4)
            check_type(argname="argument host", value=host, expected_type=type_hints["host"])
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument agent", value=agent, expected_type=type_hints["agent"])
            check_type(argname="argument agent_identity", value=agent_identity, expected_type=type_hints["agent_identity"])
            check_type(argname="argument bastion_certificate", value=bastion_certificate, expected_type=type_hints["bastion_certificate"])
            check_type(argname="argument bastion_host", value=bastion_host, expected_type=type_hints["bastion_host"])
            check_type(argname="argument bastion_host_key", value=bastion_host_key, expected_type=type_hints["bastion_host_key"])
            check_type(argname="argument bastion_password", value=bastion_password, expected_type=type_hints["bastion_password"])
            check_type(argname="argument bastion_port", value=bastion_port, expected_type=type_hints["bastion_port"])
            check_type(argname="argument bastion_private_key", value=bastion_private_key, expected_type=type_hints["bastion_private_key"])
            check_type(argname="argument bastion_user", value=bastion_user, expected_type=type_hints["bastion_user"])
            check_type(argname="argument certificate", value=certificate, expected_type=type_hints["certificate"])
            check_type(argname="argument host_key", value=host_key, expected_type=type_hints["host_key"])
            check_type(argname="argument password", value=password, expected_type=type_hints["password"])
            check_type(argname="argument port", value=port, expected_type=type_hints["port"])
            check_type(argname="argument private_key", value=private_key, expected_type=type_hints["private_key"])
            check_type(argname="argument proxy_host", value=proxy_host, expected_type=type_hints["proxy_host"])
            check_type(argname="argument proxy_port", value=proxy_port, expected_type=type_hints["proxy_port"])
            check_type(argname="argument proxy_scheme", value=proxy_scheme, expected_type=type_hints["proxy_scheme"])
            check_type(argname="argument proxy_user_name", value=proxy_user_name, expected_type=type_hints["proxy_user_name"])
            check_type(argname="argument proxy_user_password", value=proxy_user_password, expected_type=type_hints["proxy_user_password"])
            check_type(argname="argument script_path", value=script_path, expected_type=type_hints["script_path"])
            check_type(argname="argument target_platform", value=target_platform, expected_type=type_hints["target_platform"])
            check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
            check_type(argname="argument user", value=user, expected_type=type_hints["user"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "host": host,
            "type": type,
        }
        if agent is not None:
            self._values["agent"] = agent
        if agent_identity is not None:
            self._values["agent_identity"] = agent_identity
        if bastion_certificate is not None:
            self._values["bastion_certificate"] = bastion_certificate
        if bastion_host is not None:
            self._values["bastion_host"] = bastion_host
        if bastion_host_key is not None:
            self._values["bastion_host_key"] = bastion_host_key
        if bastion_password is not None:
            self._values["bastion_password"] = bastion_password
        if bastion_port is not None:
            self._values["bastion_port"] = bastion_port
        if bastion_private_key is not None:
            self._values["bastion_private_key"] = bastion_private_key
        if bastion_user is not None:
            self._values["bastion_user"] = bastion_user
        if certificate is not None:
            self._values["certificate"] = certificate
        if host_key is not None:
            self._values["host_key"] = host_key
        if password is not None:
            self._values["password"] = password
        if port is not None:
            self._values["port"] = port
        if private_key is not None:
            self._values["private_key"] = private_key
        if proxy_host is not None:
            self._values["proxy_host"] = proxy_host
        if proxy_port is not None:
            self._values["proxy_port"] = proxy_port
        if proxy_scheme is not None:
            self._values["proxy_scheme"] = proxy_scheme
        if proxy_user_name is not None:
            self._values["proxy_user_name"] = proxy_user_name
        if proxy_user_password is not None:
            self._values["proxy_user_password"] = proxy_user_password
        if script_path is not None:
            self._values["script_path"] = script_path
        if target_platform is not None:
            self._values["target_platform"] = target_platform
        if timeout is not None:
            self._values["timeout"] = timeout
        if user is not None:
            self._values["user"] = user

    @builtins.property
    def host(self) -> builtins.str:
        '''(experimental) The address of the resource to connect to.

        :stability: experimental
        '''
        result = self._values.get("host")
        assert result is not None, "Required property 'host' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def type(self) -> builtins.str:
        '''(experimental) The connection type.

        Valid values are "ssh" and "winrm".
        Provisioners typically assume that the remote system runs Microsoft Windows when using WinRM.
        Behaviors based on the SSH target_platform will force Windows-specific behavior for WinRM, unless otherwise specified.

        :stability: experimental
        '''
        result = self._values.get("type")
        assert result is not None, "Required property 'type' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def agent(self) -> typing.Optional[builtins.str]:
        '''(experimental) Set to false to disable using ssh-agent to authenticate.

        On Windows the only supported SSH authentication agent is Pageant.

        :stability: experimental
        '''
        result = self._values.get("agent")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def agent_identity(self) -> typing.Optional[builtins.str]:
        '''(experimental) The preferred identity from the ssh agent for authentication.

        :stability: experimental
        '''
        result = self._values.get("agent_identity")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def bastion_certificate(self) -> typing.Optional[builtins.str]:
        '''(experimental) The contents of a signed CA Certificate.

        The certificate argument must be used in conjunction with a bastion_private_key.
        These can be loaded from a file on disk using the the file function.

        :stability: experimental
        '''
        result = self._values.get("bastion_certificate")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def bastion_host(self) -> typing.Optional[builtins.str]:
        '''(experimental) Setting this enables the bastion Host connection.

        The provisioner will connect to bastion_host first, and then connect from there to host.

        :stability: experimental
        '''
        result = self._values.get("bastion_host")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def bastion_host_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) The public key from the remote host or the signing CA, used to verify the host connection.

        :stability: experimental
        '''
        result = self._values.get("bastion_host_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def bastion_password(self) -> typing.Optional[builtins.str]:
        '''(experimental) The password to use for the bastion host.

        :stability: experimental
        '''
        result = self._values.get("bastion_password")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def bastion_port(self) -> typing.Optional[jsii.Number]:
        '''(experimental) The port to use connect to the bastion host.

        :stability: experimental
        '''
        result = self._values.get("bastion_port")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def bastion_private_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) The contents of an SSH key file to use for the bastion host.

        These can be loaded from a file on disk using the file function.

        :stability: experimental
        '''
        result = self._values.get("bastion_private_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def bastion_user(self) -> typing.Optional[builtins.str]:
        '''(experimental) The user for the connection to the bastion host.

        :stability: experimental
        '''
        result = self._values.get("bastion_user")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def certificate(self) -> typing.Optional[builtins.str]:
        '''(experimental) The contents of a signed CA Certificate.

        The certificate argument must be used in conjunction with a private_key.
        These can be loaded from a file on disk using the the file function.

        :stability: experimental
        '''
        result = self._values.get("certificate")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def host_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) The public key from the remote host or the signing CA, used to verify the connection.

        :stability: experimental
        '''
        result = self._values.get("host_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def password(self) -> typing.Optional[builtins.str]:
        '''(experimental) The password to use for the connection.

        :stability: experimental
        '''
        result = self._values.get("password")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def port(self) -> typing.Optional[jsii.Number]:
        '''(experimental) The port to connect to.

        :default: 22

        :stability: experimental
        '''
        result = self._values.get("port")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def private_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) The contents of an SSH key to use for the connection.

        These can be loaded from a file on disk using the file function.
        This takes preference over password if provided.

        :stability: experimental
        '''
        result = self._values.get("private_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def proxy_host(self) -> typing.Optional[builtins.str]:
        '''(experimental) Setting this enables the SSH over HTTP connection.

        This host will be connected to first, and then the host or bastion_host connection will be made from there.

        :stability: experimental
        '''
        result = self._values.get("proxy_host")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def proxy_port(self) -> typing.Optional[jsii.Number]:
        '''(experimental) The port to use connect to the proxy host.

        :stability: experimental
        '''
        result = self._values.get("proxy_port")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def proxy_scheme(self) -> typing.Optional[builtins.str]:
        '''(experimental) The ssh connection also supports the following fields to facilitate connections by SSH over HTTP proxy.

        :stability: experimental
        '''
        result = self._values.get("proxy_scheme")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def proxy_user_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) The username to use connect to the private proxy host.

        This argument should be specified only if authentication is required for the HTTP Proxy server.

        :stability: experimental
        '''
        result = self._values.get("proxy_user_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def proxy_user_password(self) -> typing.Optional[builtins.str]:
        '''(experimental) The password to use connect to the private proxy host.

        This argument should be specified only if authentication is required for the HTTP Proxy server.

        :stability: experimental
        '''
        result = self._values.get("proxy_user_password")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def script_path(self) -> typing.Optional[builtins.str]:
        '''(experimental) The path used to copy scripts meant for remote execution.

        Refer to {@link https://developer.hashicorp.com/terraform/language/resources/provisioners/connection#how-provisioners-execute-remote-scripts How Provisioners Execute Remote Scripts below for more details}

        :stability: experimental
        '''
        result = self._values.get("script_path")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def target_platform(self) -> typing.Optional[builtins.str]:
        '''(experimental) The target platform to connect to.

        Valid values are "windows" and "unix".
        If the platform is set to windows, the default script_path is c:\\windows\\temp\\terraform_%RAND%.cmd, assuming the SSH default shell is cmd.exe.
        If the SSH default shell is PowerShell, set script_path to "c:/windows/temp/terraform_%RAND%.ps1"

        :default: unix

        :stability: experimental
        '''
        result = self._values.get("target_platform")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def timeout(self) -> typing.Optional[builtins.str]:
        '''(experimental) The timeout to wait for the connection to become available.

        Should be provided as a string (e.g., "30s" or "5m".)

        :default: 5m

        :stability: experimental
        '''
        result = self._values.get("timeout")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def user(self) -> typing.Optional[builtins.str]:
        '''(experimental) The user to use for the connection.

        :default: root

        :stability: experimental
        '''
        result = self._values.get("user")
        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 "SSHProvisionerConnection(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.StackAnnotation",
    jsii_struct_bases=[],
    name_mapping={
        "construct_path": "constructPath",
        "level": "level",
        "message": "message",
        "stacktrace": "stacktrace",
    },
)
class StackAnnotation:
    def __init__(
        self,
        *,
        construct_path: builtins.str,
        level: AnnotationMetadataEntryType,
        message: builtins.str,
        stacktrace: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> None:
        '''
        :param construct_path: 
        :param level: 
        :param message: 
        :param stacktrace: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7d6f2e0c8595375732d0149739981be2e163d3ed76569beae055b49833972195)
            check_type(argname="argument construct_path", value=construct_path, expected_type=type_hints["construct_path"])
            check_type(argname="argument level", value=level, expected_type=type_hints["level"])
            check_type(argname="argument message", value=message, expected_type=type_hints["message"])
            check_type(argname="argument stacktrace", value=stacktrace, expected_type=type_hints["stacktrace"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "construct_path": construct_path,
            "level": level,
            "message": message,
        }
        if stacktrace is not None:
            self._values["stacktrace"] = stacktrace

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

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

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

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


@jsii.data_type(
    jsii_type="cdktn.StackManifest",
    jsii_struct_bases=[],
    name_mapping={
        "annotations": "annotations",
        "construct_path": "constructPath",
        "dependencies": "dependencies",
        "name": "name",
        "stack_metadata_path": "stackMetadataPath",
        "synthesized_stack_path": "synthesizedStackPath",
        "working_directory": "workingDirectory",
    },
)
class StackManifest:
    def __init__(
        self,
        *,
        annotations: typing.Sequence[typing.Union[StackAnnotation, typing.Dict[builtins.str, typing.Any]]],
        construct_path: builtins.str,
        dependencies: typing.Sequence[builtins.str],
        name: builtins.str,
        stack_metadata_path: builtins.str,
        synthesized_stack_path: builtins.str,
        working_directory: builtins.str,
    ) -> None:
        '''
        :param annotations: 
        :param construct_path: 
        :param dependencies: 
        :param name: 
        :param stack_metadata_path: 
        :param synthesized_stack_path: 
        :param working_directory: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f174c237fb4d015e64a75ec04a5bb8f4030da2df56f0b3a9ea2ab222a906ce2f)
            check_type(argname="argument annotations", value=annotations, expected_type=type_hints["annotations"])
            check_type(argname="argument construct_path", value=construct_path, expected_type=type_hints["construct_path"])
            check_type(argname="argument dependencies", value=dependencies, expected_type=type_hints["dependencies"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument stack_metadata_path", value=stack_metadata_path, expected_type=type_hints["stack_metadata_path"])
            check_type(argname="argument synthesized_stack_path", value=synthesized_stack_path, expected_type=type_hints["synthesized_stack_path"])
            check_type(argname="argument working_directory", value=working_directory, expected_type=type_hints["working_directory"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "annotations": annotations,
            "construct_path": construct_path,
            "dependencies": dependencies,
            "name": name,
            "stack_metadata_path": stack_metadata_path,
            "synthesized_stack_path": synthesized_stack_path,
            "working_directory": working_directory,
        }

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

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

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

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

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

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

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


@jsii.implements(IFragmentConcatenator)
class StringConcat(metaclass=jsii.JSIIMeta, jsii_type="cdktn.StringConcat"):
    '''(experimental) Converts all fragments to strings and concats those.

    Drops 'undefined's.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="join")
    def join(self, left: typing.Any, right: typing.Any) -> typing.Any:
        '''(experimental) Concatenates string fragments.

        :param left: -
        :param right: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0d4c7d99f672e21a621737a4672daae318d14054dd144e659b369de41b7acf9a)
            check_type(argname="argument left", value=left, expected_type=type_hints["left"])
            check_type(argname="argument right", value=right, expected_type=type_hints["right"])
        return typing.cast(typing.Any, jsii.invoke(self, "join", [left, right]))


@jsii.implements(ITerraformAddressable, IResolvable)
class StringMap(metaclass=jsii.JSIIMeta, jsii_type="cdktn.StringMap"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f0258829598f3937eaacd1e76f1b51fec5354480a3d24474a5d3cd68ebdbdec2)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute])

    @jsii.member(jsii_name="computeFqn")
    def compute_fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "computeFqn", []))

    @jsii.member(jsii_name="lookup")
    def lookup(self, key: builtins.str) -> builtins.str:
        '''
        :param key: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9c6764c4f1dadab34b6621393ddab0e8872f50f47e984c66af8ea8e06386e95a)
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
        return typing.cast(builtins.str, jsii.invoke(self, "lookup", [key]))

    @jsii.member(jsii_name="resolve")
    def resolve(self, _context: IResolveContext) -> typing.Any:
        '''(experimental) Produce the Token's value at resolution time.

        :param _context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__41548a4bf795459ca25ffd9149a6377e9c63cd06407c7003b8ae18706acecbc2)
            check_type(argname="argument _context", value=_context, expected_type=type_hints["_context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolve", [_context]))

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''(experimental) Return a string representation of this resolvable object.

        Returns a reversible string representation.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @builtins.property
    @jsii.member(jsii_name="creationStack")
    def creation_stack(self) -> typing.List[builtins.str]:
        '''(experimental) The creation stack of this resolvable which will be appended to errors thrown during resolution.

        If this returns an empty array the stack will not be attached.

        :stability: experimental
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "creationStack"))

    @builtins.property
    @jsii.member(jsii_name="fqn")
    def fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "fqn"))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e453235c038c1503cd6b27519dc5b9a508876eab0175708cdea7ca82938ad036)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dd959d179f1126c444986d044c2b0070e4884693df91a36be813f56468b2e992)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]


class StringMapList(MapList, metaclass=jsii.JSIIMeta, jsii_type="cdktn.StringMapList"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
        wraps_set: builtins.bool,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -
        :param wraps_set: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a40fdb0bc0fec4ac3ee3d0addd1cd8b085ff08c801d2c4d90eb9faf012d28ef5)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
            check_type(argname="argument wraps_set", value=wraps_set, expected_type=type_hints["wraps_set"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute, wraps_set])

    @jsii.member(jsii_name="get")
    def get(self, index: jsii.Number) -> StringMap:
        '''
        :param index: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__675c4da88a632d5e4e15b9071798ca88c1bfb01b32c21155bb26a8e36df84328)
            check_type(argname="argument index", value=index, expected_type=type_hints["index"])
        return typing.cast(StringMap, jsii.invoke(self, "get", [index]))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e061386a971f4d3187cd5d78d4b3a9699c5a1b25e52f60331fef1b7124c5e9dc)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__36d6002ff6898f1e07f76fd199122ef61feac20cf8ad4625475f3b04e2cd8177)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="wrapsSet")
    def _wraps_set(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "wrapsSet"))

    @_wraps_set.setter
    def _wraps_set(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__efc36b987fc1253fc3e3709a91fc90c941b80c8e66b25cefb0aa861ea0354033)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "wrapsSet", value) # pyright: ignore[reportArgumentType]


@jsii.data_type(
    jsii_type="cdktn.SwiftBackendConfig",
    jsii_struct_bases=[],
    name_mapping={
        "container": "container",
        "application_credential_id": "applicationCredentialId",
        "application_credential_name": "applicationCredentialName",
        "application_credential_secret": "applicationCredentialSecret",
        "archive_container": "archiveContainer",
        "auth_url": "authUrl",
        "cacert_file": "cacertFile",
        "cert": "cert",
        "cloud": "cloud",
        "default_domain": "defaultDomain",
        "domain_id": "domainId",
        "domain_name": "domainName",
        "expire_after": "expireAfter",
        "insecure": "insecure",
        "key": "key",
        "password": "password",
        "project_domain_id": "projectDomainId",
        "project_domain_name": "projectDomainName",
        "region_name": "regionName",
        "state_name": "stateName",
        "tenant_id": "tenantId",
        "tenant_name": "tenantName",
        "token": "token",
        "user_domain_id": "userDomainId",
        "user_domain_name": "userDomainName",
        "user_id": "userId",
        "user_name": "userName",
    },
)
class SwiftBackendConfig:
    def __init__(
        self,
        *,
        container: builtins.str,
        application_credential_id: typing.Optional[builtins.str] = None,
        application_credential_name: typing.Optional[builtins.str] = None,
        application_credential_secret: typing.Optional[builtins.str] = None,
        archive_container: typing.Optional[builtins.str] = None,
        auth_url: typing.Optional[builtins.str] = None,
        cacert_file: typing.Optional[builtins.str] = None,
        cert: typing.Optional[builtins.str] = None,
        cloud: typing.Optional[builtins.str] = None,
        default_domain: typing.Optional[builtins.str] = None,
        domain_id: typing.Optional[builtins.str] = None,
        domain_name: typing.Optional[builtins.str] = None,
        expire_after: typing.Optional[builtins.str] = None,
        insecure: typing.Optional[builtins.bool] = None,
        key: typing.Optional[builtins.str] = None,
        password: typing.Optional[builtins.str] = None,
        project_domain_id: typing.Optional[builtins.str] = None,
        project_domain_name: typing.Optional[builtins.str] = None,
        region_name: typing.Optional[builtins.str] = None,
        state_name: typing.Optional[builtins.str] = None,
        tenant_id: typing.Optional[builtins.str] = None,
        tenant_name: typing.Optional[builtins.str] = None,
        token: typing.Optional[builtins.str] = None,
        user_domain_id: typing.Optional[builtins.str] = None,
        user_domain_name: typing.Optional[builtins.str] = None,
        user_id: typing.Optional[builtins.str] = None,
        user_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param container: 
        :param application_credential_id: 
        :param application_credential_name: 
        :param application_credential_secret: 
        :param archive_container: 
        :param auth_url: 
        :param cacert_file: 
        :param cert: 
        :param cloud: 
        :param default_domain: 
        :param domain_id: 
        :param domain_name: 
        :param expire_after: 
        :param insecure: 
        :param key: 
        :param password: 
        :param project_domain_id: 
        :param project_domain_name: 
        :param region_name: 
        :param state_name: 
        :param tenant_id: 
        :param tenant_name: 
        :param token: 
        :param user_domain_id: 
        :param user_domain_name: 
        :param user_id: 
        :param user_name: 

        :deprecated: CDK for Terraform no longer supports the swift backend. Terraform deprecated swift in v1.2.3 and removed it in v1.3.

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fc5f547e6fb2026d4300a32e9845e7ce68edf0a679b7416e8de31fc9b57c226b)
            check_type(argname="argument container", value=container, expected_type=type_hints["container"])
            check_type(argname="argument application_credential_id", value=application_credential_id, expected_type=type_hints["application_credential_id"])
            check_type(argname="argument application_credential_name", value=application_credential_name, expected_type=type_hints["application_credential_name"])
            check_type(argname="argument application_credential_secret", value=application_credential_secret, expected_type=type_hints["application_credential_secret"])
            check_type(argname="argument archive_container", value=archive_container, expected_type=type_hints["archive_container"])
            check_type(argname="argument auth_url", value=auth_url, expected_type=type_hints["auth_url"])
            check_type(argname="argument cacert_file", value=cacert_file, expected_type=type_hints["cacert_file"])
            check_type(argname="argument cert", value=cert, expected_type=type_hints["cert"])
            check_type(argname="argument cloud", value=cloud, expected_type=type_hints["cloud"])
            check_type(argname="argument default_domain", value=default_domain, expected_type=type_hints["default_domain"])
            check_type(argname="argument domain_id", value=domain_id, expected_type=type_hints["domain_id"])
            check_type(argname="argument domain_name", value=domain_name, expected_type=type_hints["domain_name"])
            check_type(argname="argument expire_after", value=expire_after, expected_type=type_hints["expire_after"])
            check_type(argname="argument insecure", value=insecure, expected_type=type_hints["insecure"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
            check_type(argname="argument password", value=password, expected_type=type_hints["password"])
            check_type(argname="argument project_domain_id", value=project_domain_id, expected_type=type_hints["project_domain_id"])
            check_type(argname="argument project_domain_name", value=project_domain_name, expected_type=type_hints["project_domain_name"])
            check_type(argname="argument region_name", value=region_name, expected_type=type_hints["region_name"])
            check_type(argname="argument state_name", value=state_name, expected_type=type_hints["state_name"])
            check_type(argname="argument tenant_id", value=tenant_id, expected_type=type_hints["tenant_id"])
            check_type(argname="argument tenant_name", value=tenant_name, expected_type=type_hints["tenant_name"])
            check_type(argname="argument token", value=token, expected_type=type_hints["token"])
            check_type(argname="argument user_domain_id", value=user_domain_id, expected_type=type_hints["user_domain_id"])
            check_type(argname="argument user_domain_name", value=user_domain_name, expected_type=type_hints["user_domain_name"])
            check_type(argname="argument user_id", value=user_id, expected_type=type_hints["user_id"])
            check_type(argname="argument user_name", value=user_name, expected_type=type_hints["user_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "container": container,
        }
        if application_credential_id is not None:
            self._values["application_credential_id"] = application_credential_id
        if application_credential_name is not None:
            self._values["application_credential_name"] = application_credential_name
        if application_credential_secret is not None:
            self._values["application_credential_secret"] = application_credential_secret
        if archive_container is not None:
            self._values["archive_container"] = archive_container
        if auth_url is not None:
            self._values["auth_url"] = auth_url
        if cacert_file is not None:
            self._values["cacert_file"] = cacert_file
        if cert is not None:
            self._values["cert"] = cert
        if cloud is not None:
            self._values["cloud"] = cloud
        if default_domain is not None:
            self._values["default_domain"] = default_domain
        if domain_id is not None:
            self._values["domain_id"] = domain_id
        if domain_name is not None:
            self._values["domain_name"] = domain_name
        if expire_after is not None:
            self._values["expire_after"] = expire_after
        if insecure is not None:
            self._values["insecure"] = insecure
        if key is not None:
            self._values["key"] = key
        if password is not None:
            self._values["password"] = password
        if project_domain_id is not None:
            self._values["project_domain_id"] = project_domain_id
        if project_domain_name is not None:
            self._values["project_domain_name"] = project_domain_name
        if region_name is not None:
            self._values["region_name"] = region_name
        if state_name is not None:
            self._values["state_name"] = state_name
        if tenant_id is not None:
            self._values["tenant_id"] = tenant_id
        if tenant_name is not None:
            self._values["tenant_name"] = tenant_name
        if token is not None:
            self._values["token"] = token
        if user_domain_id is not None:
            self._values["user_domain_id"] = user_domain_id
        if user_domain_name is not None:
            self._values["user_domain_name"] = user_domain_name
        if user_id is not None:
            self._values["user_id"] = user_id
        if user_name is not None:
            self._values["user_name"] = user_name

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


class TaggedCloudWorkspaces(
    CloudWorkspace,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.TaggedCloudWorkspaces",
):
    '''(experimental) A set of Terraform Cloud workspace tags.

    You will be able to use this working directory with any workspaces that have all of the specified tags, and can use the terraform workspace commands to switch between them or create new workspaces. New workspaces will automatically have the specified tags. This option conflicts with name.

    :stability: experimental
    '''

    def __init__(
        self,
        tags: typing.Sequence[builtins.str],
        project: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param tags: -
        :param project: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a63ad742b06a1fc5c49fa8e353485748e0bed2af1637430e96dd29a98c24f9f7)
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument project", value=project, expected_type=type_hints["project"])
        jsii.create(self.__class__, self, [tags, project])

    @jsii.member(jsii_name="toHclTerraform")
    def to_hcl_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toHclTerraform", []))

    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toTerraform", []))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> typing.List[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "tags"))

    @tags.setter
    def tags(self, value: typing.List[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__33141984c345982077d6f4e6b9dd8b925bafebea3ba27b44db4774fa5bdba72e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tags", value) # pyright: ignore[reportArgumentType]

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

    @project.setter
    def project(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aa1d75ec4a2d0804ac24830d48635da71ca8dd59487a37a167f552a06e74225e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "project", value) # pyright: ignore[reportArgumentType]


class TerraformAsset(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.TerraformAsset",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        path: builtins.str,
        asset_hash: typing.Optional[builtins.str] = None,
        type: typing.Optional[AssetType] = None,
    ) -> None:
        '''(experimental) A Terraform Asset takes a file or directory outside of the CDK Terrain context and moves it into it.

        Assets copy referenced files into the stacks context for further usage in other resources.

        :param scope: -
        :param id: -
        :param path: 
        :param asset_hash: 
        :param type: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6f29998a5dacee0da3977e8d51379662670eb6942990ac7e6e052ab5e3408d37)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = TerraformAssetConfig(path=path, asset_hash=asset_hash, type=type)

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

    @builtins.property
    @jsii.member(jsii_name="fileName")
    def file_name(self) -> builtins.str:
        '''(experimental) Name of the asset.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "fileName"))

    @builtins.property
    @jsii.member(jsii_name="path")
    def path(self) -> builtins.str:
        '''(experimental) The path relative to the root of the terraform directory in posix format Use this property to reference the asset.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "path"))

    @builtins.property
    @jsii.member(jsii_name="assetHash")
    def asset_hash(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "assetHash"))

    @asset_hash.setter
    def asset_hash(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__23ec3c47a72004f913af4cf9d52dc80854bd7b62507f8b9a74251d7d31d29d96)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "assetHash", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> AssetType:
        '''
        :stability: experimental
        '''
        return typing.cast(AssetType, jsii.get(self, "type"))

    @type.setter
    def type(self, value: AssetType) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__03e61b89f49ef71fd8419a85339e3b4fbecbbadc295011656c2629a600c3d734)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "type", value) # pyright: ignore[reportArgumentType]


@jsii.data_type(
    jsii_type="cdktn.TerraformAssetConfig",
    jsii_struct_bases=[],
    name_mapping={"path": "path", "asset_hash": "assetHash", "type": "type"},
)
class TerraformAssetConfig:
    def __init__(
        self,
        *,
        path: builtins.str,
        asset_hash: typing.Optional[builtins.str] = None,
        type: typing.Optional[AssetType] = None,
    ) -> None:
        '''
        :param path: 
        :param asset_hash: 
        :param type: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e7a613b39a707470fb3fa76a5d5d750aa8285bec8b92786190d69d5b7f66db39)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
            check_type(argname="argument asset_hash", value=asset_hash, expected_type=type_hints["asset_hash"])
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "path": path,
        }
        if asset_hash is not None:
            self._values["asset_hash"] = asset_hash
        if type is not None:
            self._values["type"] = type

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

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

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


@jsii.data_type(
    jsii_type="cdktn.TerraformCondition",
    jsii_struct_bases=[],
    name_mapping={"condition": "condition", "error_message": "errorMessage"},
)
class TerraformCondition:
    def __init__(self, *, condition: typing.Any, error_message: builtins.str) -> None:
        '''
        :param condition: (experimental) This is a boolean expression that should return true if the intended assumption or guarantee is fulfilled or false if it does not.
        :param error_message: (experimental) This contains the text that Terraform will include as part of error messages when it detects an unmet condition.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b336eac40603f44d46efd6bbf0d28b18b4f8355cc2e560877096240a812f968a)
            check_type(argname="argument condition", value=condition, expected_type=type_hints["condition"])
            check_type(argname="argument error_message", value=error_message, expected_type=type_hints["error_message"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "condition": condition,
            "error_message": error_message,
        }

    @builtins.property
    def condition(self) -> typing.Any:
        '''(experimental) This is a boolean expression that should return true if the intended assumption or guarantee is fulfilled or false if it does not.

        :stability: experimental
        '''
        result = self._values.get("condition")
        assert result is not None, "Required property 'condition' is missing"
        return typing.cast(typing.Any, result)

    @builtins.property
    def error_message(self) -> builtins.str:
        '''(experimental) This contains the text that Terraform will include as part of error messages when it detects an unmet condition.

        :stability: experimental
        '''
        result = self._values.get("error_message")
        assert result is not None, "Required property 'error_message' 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 "TerraformCondition(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class TerraformCount(metaclass=jsii.JSIIMeta, jsii_type="cdktn.TerraformCount"):
    '''(experimental) Iterator for the Terraform count property.

    :stability: experimental
    '''

    @jsii.member(jsii_name="isTerraformCount")
    @builtins.classmethod
    def is_terraform_count(cls, x: typing.Any) -> builtins.bool:
        '''
        :param x: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eeca2019246585cba23b2b3e8324a60dc582fb110dae06b370f63471b7e7f438)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "isTerraformCount", [x]))

    @jsii.member(jsii_name="of")
    @builtins.classmethod
    def of(cls, count: jsii.Number) -> "TerraformCount":
        '''
        :param count: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9a8c063de56f4d554799a5d672e4ecc8be3bd1ed0542261b0ff8825bfe1fd74d)
            check_type(argname="argument count", value=count, expected_type=type_hints["count"])
        return typing.cast("TerraformCount", jsii.sinvoke(cls, "of", [count]))

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        return typing.cast(jsii.Number, jsii.invoke(self, "toTerraform", []))

    @builtins.property
    @jsii.member(jsii_name="index")
    def index(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        return typing.cast(jsii.Number, jsii.get(self, "index"))


class TerraformElement(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.TerraformElement",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        element_type: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param element_type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4f08acb0cd64930d96b3487305cdc472bee5a9bf175463954da18f0e0d8e6f46)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument element_type", value=element_type, expected_type=type_hints["element_type"])
        jsii.create(self.__class__, self, [scope, id, element_type])

    @jsii.member(jsii_name="isTerraformElement")
    @builtins.classmethod
    def is_terraform_element(cls, x: typing.Any) -> builtins.bool:
        '''
        :param x: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fcd359885858fd4c036b7dd13adff5090336398ffc28d3b3f4c939535f39b33b)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "isTerraformElement", [x]))

    @jsii.member(jsii_name="addOverride")
    def add_override(self, path: builtins.str, value: typing.Any) -> None:
        '''
        :param path: -
        :param value: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5061998df7e324559c25dd72d32954de6d29a1dccc5e5c379864e487659bf85d)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        return typing.cast(None, jsii.invoke(self, "addOverride", [path, value]))

    @jsii.member(jsii_name="overrideLogicalId")
    def override_logical_id(self, new_logical_id: builtins.str) -> None:
        '''(experimental) Overrides the auto-generated logical ID with a specific ID.

        :param new_logical_id: The new logical ID to use for this stack element.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__83b5539188c731eded2b9f18fd28eb77d70b555547e688d34178813ad809ecb1)
            check_type(argname="argument new_logical_id", value=new_logical_id, expected_type=type_hints["new_logical_id"])
        return typing.cast(None, jsii.invoke(self, "overrideLogicalId", [new_logical_id]))

    @jsii.member(jsii_name="resetOverrideLogicalId")
    def reset_override_logical_id(self) -> None:
        '''(experimental) Resets a previously passed logical Id to use the auto-generated logical id again.

        :stability: experimental
        '''
        return typing.cast(None, jsii.invoke(self, "resetOverrideLogicalId", []))

    @jsii.member(jsii_name="toHclTerraform")
    def to_hcl_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toHclTerraform", []))

    @jsii.member(jsii_name="toMetadata")
    def to_metadata(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toMetadata", []))

    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toTerraform", []))

    @builtins.property
    @jsii.member(jsii_name="cdktfStack")
    def cdktf_stack(self) -> "TerraformStack":
        '''
        :stability: experimental
        '''
        return typing.cast("TerraformStack", jsii.get(self, "cdktfStack"))

    @builtins.property
    @jsii.member(jsii_name="constructNodeMetadata")
    def _construct_node_metadata(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "constructNodeMetadata"))

    @builtins.property
    @jsii.member(jsii_name="fqn")
    def fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "fqn"))

    @builtins.property
    @jsii.member(jsii_name="friendlyUniqueId")
    def friendly_unique_id(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "friendlyUniqueId"))

    @builtins.property
    @jsii.member(jsii_name="rawOverrides")
    def _raw_overrides(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.get(self, "rawOverrides"))


@jsii.data_type(
    jsii_type="cdktn.TerraformElementMetadata",
    jsii_struct_bases=[],
    name_mapping={
        "path": "path",
        "stack_trace": "stackTrace",
        "unique_id": "uniqueId",
    },
)
class TerraformElementMetadata:
    def __init__(
        self,
        *,
        path: builtins.str,
        stack_trace: typing.Sequence[builtins.str],
        unique_id: builtins.str,
    ) -> None:
        '''
        :param path: 
        :param stack_trace: 
        :param unique_id: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fab9ced444c289534f0982bd872b70f1bcfed9fbdf3b06afeeff1085fa01aada)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
            check_type(argname="argument stack_trace", value=stack_trace, expected_type=type_hints["stack_trace"])
            check_type(argname="argument unique_id", value=unique_id, expected_type=type_hints["unique_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "path": path,
            "stack_trace": stack_trace,
            "unique_id": unique_id,
        }

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

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

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


@jsii.implements(ITerraformIterator)
class TerraformIterator(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="cdktn.TerraformIterator",
):
    '''
    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="fromComplexList")
    @builtins.classmethod
    def from_complex_list(
        cls,
        list: typing.Union[IResolvable, "ComplexList", StringMapList, NumberMapList, "BooleanMapList", "AnyMapList"],
        map_key_attribute_name: builtins.str,
    ) -> "DynamicListTerraformIterator":
        '''(experimental) Creates a new iterator from a complex list.

        One example for this would be a list of maps.
        The list will be converted into a map with the mapKeyAttributeName as the key.

        :param list: the list to iterate over.
        :param map_key_attribute_name: the name of the attribute that should be used as the key in the map. Visit https://developer.hashicorp.com/terraform/cdktf/concepts/iterators#using-iterators-on-complex-lists for more information.

        :stability: experimental

        Example::

            const cert = new AcmCertificate(this, "cert", {
               domainName: "example.com",
               validationMethod: "DNS",
             });
            
            const dvoIterator = TerraformIterator.fromComplexList(
              cert.domainValidationOptions,
              "domain_name"
            );
            
            new Route53Record(this, "record", {
              allowOverwrite: true,
              name: dvoIterator.getString("name"),
              records: [dvoIterator.getString("record")],
              ttl: 60,
              type: dvoIterator.getString("type"),
              zoneId: Token.asString(dataAwsRoute53ZoneExample.zoneId),
              forEach: dvoIterator,
            });
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__06225d88c1d051bbf50c7b8a4b6efbad356c54a8d5a98d873eddc798401e5267)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
            check_type(argname="argument map_key_attribute_name", value=map_key_attribute_name, expected_type=type_hints["map_key_attribute_name"])
        return typing.cast("DynamicListTerraformIterator", jsii.sinvoke(cls, "fromComplexList", [list, map_key_attribute_name]))

    @jsii.member(jsii_name="fromDataSources")
    @builtins.classmethod
    def from_data_sources(
        cls,
        resource: ITerraformResource,
    ) -> "ResourceTerraformIterator":
        '''(experimental) Creates a new iterator from a data source that has been created with the ``for_each`` argument.

        :param resource: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ca407881f880f526ecdd3a655df6d825fc639b63e1ab866c3e8b2d48447fe872)
            check_type(argname="argument resource", value=resource, expected_type=type_hints["resource"])
        return typing.cast("ResourceTerraformIterator", jsii.sinvoke(cls, "fromDataSources", [resource]))

    @jsii.member(jsii_name="fromList")
    @builtins.classmethod
    def from_list(
        cls,
        list: typing.Union[typing.Sequence[builtins.str], IResolvable, typing.Sequence[jsii.Number], typing.Sequence[typing.Union[builtins.bool, IResolvable]]],
    ) -> "ListTerraformIterator":
        '''(experimental) Creates a new iterator from a list.

        :param list: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4a3bd134e34b1f954589c409619eaeafb56545bc18372876271e5377410bd32d)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
        return typing.cast("ListTerraformIterator", jsii.sinvoke(cls, "fromList", [list]))

    @jsii.member(jsii_name="fromMap")
    @builtins.classmethod
    def from_map(
        cls,
        map: typing.Union["ComplexMap", typing.Mapping[builtins.str, typing.Any], typing.Mapping[builtins.str, builtins.str], typing.Mapping[builtins.str, jsii.Number], typing.Mapping[builtins.str, builtins.bool]],
    ) -> "MapTerraformIterator":
        '''(experimental) Creates a new iterator from a map.

        :param map: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b5a1bc5fff8fe1a366a4355a93a2bf1b8624d6d39212e735ca891cc1859c94ee)
            check_type(argname="argument map", value=map, expected_type=type_hints["map"])
        return typing.cast("MapTerraformIterator", jsii.sinvoke(cls, "fromMap", [map]))

    @jsii.member(jsii_name="fromResources")
    @builtins.classmethod
    def from_resources(
        cls,
        resource: ITerraformResource,
    ) -> "ResourceTerraformIterator":
        '''(experimental) Creates a new iterator from a resource that has been created with the ``for_each`` argument.

        :param resource: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d68664120105ffaeb47463bd04a63052d25e722da1abe9bfe4699b6e462f365e)
            check_type(argname="argument resource", value=resource, expected_type=type_hints["resource"])
        return typing.cast("ResourceTerraformIterator", jsii.sinvoke(cls, "fromResources", [resource]))

    @jsii.member(jsii_name="dynamic")
    def dynamic(
        self,
        attributes: typing.Mapping[builtins.str, typing.Any],
    ) -> IResolvable:
        '''(experimental) Creates a dynamic expression that can be used to loop over this iterator in a dynamic block.

        As this returns an IResolvable you might need to wrap the output in
        a Token, e.g. ``Token.asString``.
        See https://developer.hashicorp.com/terraform/cdktf/concepts/iterators#using-iterators-for-list-attributes

        :param attributes: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f6ff49e0709ba3c7a5293c56a6a93c2bdc5d053661277717c36f8a6611722d95)
            check_type(argname="argument attributes", value=attributes, expected_type=type_hints["attributes"])
        return typing.cast(IResolvable, jsii.invoke(self, "dynamic", [attributes]))

    @jsii.member(jsii_name="forExpressionForList")
    def for_expression_for_list(
        self,
        expression: typing.Union[builtins.str, IResolvable],
    ) -> IResolvable:
        '''(experimental) Creates a for expression that results in a list.

        This method allows you to create every possible for expression, but requires more knowledge about
        Terraform's for expression syntax.
        For the most common use cases you can use keys(), values(), and pluckProperty() instead.

        You may write any valid Terraform for each expression, e.g.
        ``TerraformIterator.fromList(myIteratorSourceVar).forExpressionForList("val.foo if val.bar == true")``
        will result in ``[ for key, val in var.myIteratorSource: val.foo if val.bar == true ]``.

        As this returns an IResolvable you might need to wrap the output in
        a Token, e.g. ``Token.asString``.

        :param expression: The expression to use in the for mapping.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f2ee0c14aec737178e77676264491d3838151340d4b3e9ed7cafa29534f73884)
            check_type(argname="argument expression", value=expression, expected_type=type_hints["expression"])
        return typing.cast(IResolvable, jsii.invoke(self, "forExpressionForList", [expression]))

    @jsii.member(jsii_name="forExpressionForMap")
    def for_expression_for_map(
        self,
        key_expression: typing.Union[builtins.str, IResolvable],
        value_expression: typing.Union[builtins.str, IResolvable],
    ) -> IResolvable:
        '''(experimental) Creates a for expression that results in a map.

        This method allows you to create every possible for expression, but requires more knowledge about
        Terraforms for expression syntax.
        For the most common use cases you can use keys(), values(), and pluckProperty instead.

        You may write any valid Terraform for each expression, e.g.
        ``TerraformIterator.fromMap(myIteratorSourceVar).forExpressionForMap("key", "val.foo if val.bar == true")``
        will result in ``{ for key, val in var.myIteratorSource: key => val.foo if val.bar == true }``.

        As this returns an IResolvable you might need to wrap the output in
        a Token, e.g. ``Token.asString``.

        :param key_expression: The expression to use as key in the for mapping.
        :param value_expression: The expression to use as value in the for mapping.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a13efbc792c82bf1a2cfacfdc8c9f74699a8c3bfa9bd30bde11bd096a39cf582)
            check_type(argname="argument key_expression", value=key_expression, expected_type=type_hints["key_expression"])
            check_type(argname="argument value_expression", value=value_expression, expected_type=type_hints["value_expression"])
        return typing.cast(IResolvable, jsii.invoke(self, "forExpressionForMap", [key_expression, value_expression]))

    @jsii.member(jsii_name="getAny")
    def get_any(self, attribute: builtins.str) -> IResolvable:
        '''
        :param attribute: name of the property to retrieve.

        :return: the given attribute of the current item iterated over as any

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dae980616c5fa32972aebf6dd37424aa0c753ce1d6fddae24d77e752802c6883)
            check_type(argname="argument attribute", value=attribute, expected_type=type_hints["attribute"])
        return typing.cast(IResolvable, jsii.invoke(self, "getAny", [attribute]))

    @jsii.member(jsii_name="getAnyMap")
    def get_any_map(
        self,
        attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param attribute: name of the property to retrieve.

        :return: the given attribute of the current item iterated over as a map of any

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ab1d8dea92912fba62653c92fa05ca18618b8504d3c95431bf4672148937f004)
            check_type(argname="argument attribute", value=attribute, expected_type=type_hints["attribute"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "getAnyMap", [attribute]))

    @jsii.member(jsii_name="getBoolean")
    def get_boolean(self, attribute: builtins.str) -> IResolvable:
        '''
        :param attribute: name of the property to retrieve.

        :return: the given attribute of the current item iterated over as a boolean

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b3d53cdd392ad9a735e5ee79dd1b6e82ab53b9cc12f2748f8d8a078748a73490)
            check_type(argname="argument attribute", value=attribute, expected_type=type_hints["attribute"])
        return typing.cast(IResolvable, jsii.invoke(self, "getBoolean", [attribute]))

    @jsii.member(jsii_name="getBooleanMap")
    def get_boolean_map(
        self,
        attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, builtins.bool]:
        '''
        :param attribute: name of the property to retrieve.

        :return: the given attribute of the current item iterated over as a map of booleans

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5e3d1060262ff44e1b4be85f1cdc7b89ebca8dec46e463300c71d5be2444f112)
            check_type(argname="argument attribute", value=attribute, expected_type=type_hints["attribute"])
        return typing.cast(typing.Mapping[builtins.str, builtins.bool], jsii.invoke(self, "getBooleanMap", [attribute]))

    @jsii.member(jsii_name="getList")
    def get_list(self, attribute: builtins.str) -> typing.List[builtins.str]:
        '''
        :param attribute: name of the property to retrieve.

        :return: the given attribute of the current item iterated over as a (string) list

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1d88be8b325eb076fceaca1217dd2a48a22f4aa43feef2d4bb71d67a8c8a722e)
            check_type(argname="argument attribute", value=attribute, expected_type=type_hints["attribute"])
        return typing.cast(typing.List[builtins.str], jsii.invoke(self, "getList", [attribute]))

    @jsii.member(jsii_name="getMap")
    def get_map(
        self,
        attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param attribute: name of the property to retrieve.

        :return: the given attribute of the current item iterated over as a map

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b8e0c3b128f6602a9fb25da88c9f2d8e462fed63f1cd76666488cd64dccf008b)
            check_type(argname="argument attribute", value=attribute, expected_type=type_hints["attribute"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "getMap", [attribute]))

    @jsii.member(jsii_name="getNumber")
    def get_number(self, attribute: builtins.str) -> jsii.Number:
        '''
        :param attribute: name of the property to retrieve.

        :return: the given attribute of the current item iterated over as a number

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__94280ae5fafddeba6e796af325c9084db55a6ee86ee425280b75997bebd3cb2c)
            check_type(argname="argument attribute", value=attribute, expected_type=type_hints["attribute"])
        return typing.cast(jsii.Number, jsii.invoke(self, "getNumber", [attribute]))

    @jsii.member(jsii_name="getNumberList")
    def get_number_list(self, attribute: builtins.str) -> typing.List[jsii.Number]:
        '''
        :param attribute: name of the property to retrieve.

        :return: the given attribute of the current item iterated over as a number list

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__35c0ad2b8ac69f1a31d8ea7ee46a0ac1bc0416a57da426e9a2bac04f4c0ad528)
            check_type(argname="argument attribute", value=attribute, expected_type=type_hints["attribute"])
        return typing.cast(typing.List[jsii.Number], jsii.invoke(self, "getNumberList", [attribute]))

    @jsii.member(jsii_name="getNumberMap")
    def get_number_map(
        self,
        attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, jsii.Number]:
        '''
        :param attribute: name of the property to retrieve.

        :return: the given attribute of the current item iterated over as a map of numbers

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__179bbbdaee7bf3055f50bdfc3ac39fd4359c3347fc31034874f39bed521e6eed)
            check_type(argname="argument attribute", value=attribute, expected_type=type_hints["attribute"])
        return typing.cast(typing.Mapping[builtins.str, jsii.Number], jsii.invoke(self, "getNumberMap", [attribute]))

    @jsii.member(jsii_name="getString")
    def get_string(self, attribute: builtins.str) -> builtins.str:
        '''
        :param attribute: name of the property to retrieve.

        :return: the given attribute of the current item iterated over as a string

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__95c3b67ed1a9e82c40b95e90af99bf4b63874a8a32d1455682d62dbbb34e5ac2)
            check_type(argname="argument attribute", value=attribute, expected_type=type_hints["attribute"])
        return typing.cast(builtins.str, jsii.invoke(self, "getString", [attribute]))

    @jsii.member(jsii_name="getStringMap")
    def get_string_map(
        self,
        attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :param attribute: name of the property to retrieve.

        :return: the given attribute of the current item iterated over as a map of strings

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b25d01f70110b734b5c3a3225cca2c2a5b1923c001986873947a220423e6d473)
            check_type(argname="argument attribute", value=attribute, expected_type=type_hints["attribute"])
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.invoke(self, "getStringMap", [attribute]))

    @jsii.member(jsii_name="keys")
    def keys(self) -> IResolvable:
        '''(experimental) Creates a for expression that maps the iterators to its keys.

        For lists these would be the indices, for maps the keys.
        As this returns an IResolvable you might need to wrap the output in
        a Token, e.g. ``Token.asString``.

        :stability: experimental
        '''
        return typing.cast(IResolvable, jsii.invoke(self, "keys", []))

    @jsii.member(jsii_name="pluckProperty")
    def pluck_property(self, property: builtins.str) -> IResolvable:
        '''(experimental) Creates a for expression that accesses the key on each element of the iterator.

        As this returns an IResolvable you might need to wrap the output in
        a Token, e.g. ``Token.asString``.

        :param property: The property of the iterators values to map to.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f1bf5cb79e73fa4038722440090309896921b37c5511f56abd0a05b47eed484f)
            check_type(argname="argument property", value=property, expected_type=type_hints["property"])
        return typing.cast(IResolvable, jsii.invoke(self, "pluckProperty", [property]))

    @jsii.member(jsii_name="values")
    def values(self) -> IResolvable:
        '''(experimental) Creates a for expression that maps the iterators to its value in case it is a map.

        For lists these would stay the same.
        As this returns an IResolvable you might need to wrap the output in
        a Token, e.g. ``Token.asString``.

        :stability: experimental
        '''
        return typing.cast(IResolvable, jsii.invoke(self, "values", []))


class _TerraformIteratorProxy(TerraformIterator):
    pass

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


@jsii.implements(ITerraformAddressable)
class TerraformLocal(
    TerraformElement,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.TerraformLocal",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        expression: typing.Any,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param expression: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2d49f62fd3d83fad9b170b2f06bea7ae5127def3a7fc98fdbc0cbb181f9d7f0c)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument expression", value=expression, expected_type=type_hints["expression"])
        jsii.create(self.__class__, self, [scope, id, expression])

    @jsii.member(jsii_name="toHclTerraform")
    def to_hcl_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toHclTerraform", []))

    @jsii.member(jsii_name="toMetadata")
    def to_metadata(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toMetadata", []))

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''(experimental) Returns a string representation of this construct.

        :return: a string token referencing the value of this local

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toTerraform", []))

    @builtins.property
    @jsii.member(jsii_name="asAnyMap")
    def as_any_map(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "asAnyMap"))

    @builtins.property
    @jsii.member(jsii_name="asBoolean")
    def as_boolean(self) -> IResolvable:
        '''
        :stability: experimental
        '''
        return typing.cast(IResolvable, jsii.get(self, "asBoolean"))

    @builtins.property
    @jsii.member(jsii_name="asBooleanMap")
    def as_boolean_map(self) -> typing.Mapping[builtins.str, builtins.bool]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.bool], jsii.get(self, "asBooleanMap"))

    @builtins.property
    @jsii.member(jsii_name="asList")
    def as_list(self) -> typing.List[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "asList"))

    @builtins.property
    @jsii.member(jsii_name="asNumber")
    def as_number(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        return typing.cast(jsii.Number, jsii.get(self, "asNumber"))

    @builtins.property
    @jsii.member(jsii_name="asNumberMap")
    def as_number_map(self) -> typing.Mapping[builtins.str, jsii.Number]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, jsii.Number], jsii.get(self, "asNumberMap"))

    @builtins.property
    @jsii.member(jsii_name="asString")
    def as_string(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "asString"))

    @builtins.property
    @jsii.member(jsii_name="asStringMap")
    def as_string_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "asStringMap"))

    @builtins.property
    @jsii.member(jsii_name="expression")
    def expression(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.get(self, "expression"))

    @expression.setter
    def expression(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f0d11d1d44304e7881d94179c7891ba6064f89e001bfcb83cf61759cde052195)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "expression", value) # pyright: ignore[reportArgumentType]


@jsii.data_type(
    jsii_type="cdktn.TerraformMetaArguments",
    jsii_struct_bases=[],
    name_mapping={
        "connection": "connection",
        "count": "count",
        "depends_on": "dependsOn",
        "for_each": "forEach",
        "lifecycle": "lifecycle",
        "provider": "provider",
        "provisioners": "provisioners",
    },
)
class TerraformMetaArguments:
    def __init__(
        self,
        *,
        connection: typing.Optional[typing.Union[typing.Union[SSHProvisionerConnection, typing.Dict[builtins.str, typing.Any]], typing.Union["WinrmProvisionerConnection", typing.Dict[builtins.str, typing.Any]]]] = None,
        count: typing.Optional[typing.Union[jsii.Number, TerraformCount]] = None,
        depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
        for_each: typing.Optional[ITerraformIterator] = None,
        lifecycle: typing.Optional[typing.Union["TerraformResourceLifecycle", typing.Dict[builtins.str, typing.Any]]] = None,
        provider: typing.Optional["TerraformProvider"] = None,
        provisioners: typing.Optional[typing.Sequence[typing.Union[typing.Union[FileProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[LocalExecProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[RemoteExecProvisioner, typing.Dict[builtins.str, typing.Any]]]]] = None,
    ) -> None:
        '''
        :param connection: 
        :param count: 
        :param depends_on: 
        :param for_each: 
        :param lifecycle: 
        :param provider: 
        :param provisioners: 

        :stability: experimental
        '''
        if isinstance(lifecycle, dict):
            lifecycle = TerraformResourceLifecycle(**lifecycle)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b02860c1b4e814c6510c34c670b9b99b042f7be44fe49a1bd323776b951bbc99)
            check_type(argname="argument connection", value=connection, expected_type=type_hints["connection"])
            check_type(argname="argument count", value=count, expected_type=type_hints["count"])
            check_type(argname="argument depends_on", value=depends_on, expected_type=type_hints["depends_on"])
            check_type(argname="argument for_each", value=for_each, expected_type=type_hints["for_each"])
            check_type(argname="argument lifecycle", value=lifecycle, expected_type=type_hints["lifecycle"])
            check_type(argname="argument provider", value=provider, expected_type=type_hints["provider"])
            check_type(argname="argument provisioners", value=provisioners, expected_type=type_hints["provisioners"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if connection is not None:
            self._values["connection"] = connection
        if count is not None:
            self._values["count"] = count
        if depends_on is not None:
            self._values["depends_on"] = depends_on
        if for_each is not None:
            self._values["for_each"] = for_each
        if lifecycle is not None:
            self._values["lifecycle"] = lifecycle
        if provider is not None:
            self._values["provider"] = provider
        if provisioners is not None:
            self._values["provisioners"] = provisioners

    @builtins.property
    def connection(
        self,
    ) -> typing.Optional[typing.Union[SSHProvisionerConnection, "WinrmProvisionerConnection"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("connection")
        return typing.cast(typing.Optional[typing.Union[SSHProvisionerConnection, "WinrmProvisionerConnection"]], result)

    @builtins.property
    def count(self) -> typing.Optional[typing.Union[jsii.Number, TerraformCount]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("count")
        return typing.cast(typing.Optional[typing.Union[jsii.Number, TerraformCount]], result)

    @builtins.property
    def depends_on(self) -> typing.Optional[typing.List[ITerraformDependable]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("depends_on")
        return typing.cast(typing.Optional[typing.List[ITerraformDependable]], result)

    @builtins.property
    def for_each(self) -> typing.Optional[ITerraformIterator]:
        '''
        :stability: experimental
        '''
        result = self._values.get("for_each")
        return typing.cast(typing.Optional[ITerraformIterator], result)

    @builtins.property
    def lifecycle(self) -> typing.Optional["TerraformResourceLifecycle"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("lifecycle")
        return typing.cast(typing.Optional["TerraformResourceLifecycle"], result)

    @builtins.property
    def provider(self) -> typing.Optional["TerraformProvider"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("provider")
        return typing.cast(typing.Optional["TerraformProvider"], result)

    @builtins.property
    def provisioners(
        self,
    ) -> typing.Optional[typing.List[typing.Union[FileProvisioner, LocalExecProvisioner, RemoteExecProvisioner]]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("provisioners")
        return typing.cast(typing.Optional[typing.List[typing.Union[FileProvisioner, LocalExecProvisioner, RemoteExecProvisioner]]], 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 "TerraformMetaArguments(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(ITerraformDependable)
class TerraformModule(
    TerraformElement,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="cdktn.TerraformModule",
):
    '''(experimental) TerraformModule can be used to reference a local terraform module or a module from the Terraform Registry.

    It should be used if you can not use generated bindings for the module as you would get by adding the module
    to your cdktf.json files "terraformModules" array and running cdktn get.

    This class is not creating a Terraform module to be used outside of CDKTN.
    If you want to bundle certain resources together like you would do with a Terraform module,
    you should use Constructs instead, see http://cdk.tf/constructs for more details.

    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        source: builtins.str,
        version: typing.Optional[builtins.str] = None,
        depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
        for_each: typing.Optional[ITerraformIterator] = None,
        providers: typing.Optional[typing.Sequence[typing.Union["TerraformProvider", typing.Union["TerraformModuleProvider", typing.Dict[builtins.str, typing.Any]]]]] = None,
        skip_asset_creation_from_local_modules: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param source: 
        :param version: 
        :param depends_on: 
        :param for_each: 
        :param providers: 
        :param skip_asset_creation_from_local_modules: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__453f55919a014c6d4e1928655313b12ae89cf53fcb1f7c930e6a341ba17a0701)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = TerraformModuleConfig(
            source=source,
            version=version,
            depends_on=depends_on,
            for_each=for_each,
            providers=providers,
            skip_asset_creation_from_local_modules=skip_asset_creation_from_local_modules,
        )

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

    @jsii.member(jsii_name="addProvider")
    def add_provider(
        self,
        provider: typing.Union["TerraformProvider", typing.Union["TerraformModuleProvider", typing.Dict[builtins.str, typing.Any]]],
    ) -> None:
        '''
        :param provider: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__12185f792feee97ba778dd08b9bd26dcddf88d78ec3e491fe6c18558242c041b)
            check_type(argname="argument provider", value=provider, expected_type=type_hints["provider"])
        return typing.cast(None, jsii.invoke(self, "addProvider", [provider]))

    @jsii.member(jsii_name="getString")
    def get_string(self, output: builtins.str) -> builtins.str:
        '''
        :param output: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2232a7d1641b826cc2f132ff62f6ceb5b095a11a0ddf3ebfc4dc69321c0ef3c7)
            check_type(argname="argument output", value=output, expected_type=type_hints["output"])
        return typing.cast(builtins.str, jsii.invoke(self, "getString", [output]))

    @jsii.member(jsii_name="interpolationForOutput")
    def interpolation_for_output(self, module_output: builtins.str) -> IResolvable:
        '''
        :param module_output: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3174cf93744c201fa8db1f5ba46a9c3b4bcb65295b531a3064f3b481aef1d23d)
            check_type(argname="argument module_output", value=module_output, expected_type=type_hints["module_output"])
        return typing.cast(IResolvable, jsii.invoke(self, "interpolationForOutput", [module_output]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))

    @jsii.member(jsii_name="toHclTerraform")
    def to_hcl_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toHclTerraform", []))

    @jsii.member(jsii_name="toMetadata")
    def to_metadata(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toMetadata", []))

    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toTerraform", []))

    @builtins.property
    @jsii.member(jsii_name="source")
    def source(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "source"))

    @builtins.property
    @jsii.member(jsii_name="providers")
    def providers(
        self,
    ) -> typing.Optional[typing.List[typing.Union["TerraformProvider", "TerraformModuleProvider"]]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.List[typing.Union["TerraformProvider", "TerraformModuleProvider"]]], jsii.get(self, "providers"))

    @builtins.property
    @jsii.member(jsii_name="skipAssetCreationFromLocalModules")
    def skip_asset_creation_from_local_modules(self) -> typing.Optional[builtins.bool]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "skipAssetCreationFromLocalModules"))

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

    @builtins.property
    @jsii.member(jsii_name="dependsOn")
    def depends_on(self) -> typing.Optional[typing.List[builtins.str]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "dependsOn"))

    @depends_on.setter
    def depends_on(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__20e56226fee23b61f9cbada36fe7f3f784d137a5a44240bac904f7cff04970b5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "dependsOn", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="forEach")
    def for_each(self) -> typing.Optional[ITerraformIterator]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[ITerraformIterator], jsii.get(self, "forEach"))

    @for_each.setter
    def for_each(self, value: typing.Optional[ITerraformIterator]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2c058963ccef1fd756c074cae46440ea9292f3b88600d0b8118795c451facd9d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "forEach", value) # pyright: ignore[reportArgumentType]


class _TerraformModuleProxy(TerraformModule):
    pass

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


@jsii.data_type(
    jsii_type="cdktn.TerraformModuleProvider",
    jsii_struct_bases=[],
    name_mapping={"module_alias": "moduleAlias", "provider": "provider"},
)
class TerraformModuleProvider:
    def __init__(
        self,
        *,
        module_alias: builtins.str,
        provider: "TerraformProvider",
    ) -> None:
        '''
        :param module_alias: 
        :param provider: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8304af0223196c2f94796cfb2497677c9e68924b90d193da74f07a304f1860c1)
            check_type(argname="argument module_alias", value=module_alias, expected_type=type_hints["module_alias"])
            check_type(argname="argument provider", value=provider, expected_type=type_hints["provider"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "module_alias": module_alias,
            "provider": provider,
        }

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

    @builtins.property
    def provider(self) -> "TerraformProvider":
        '''
        :stability: experimental
        '''
        result = self._values.get("provider")
        assert result is not None, "Required property 'provider' is missing"
        return typing.cast("TerraformProvider", 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 "TerraformModuleProvider(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.TerraformModuleUserConfig",
    jsii_struct_bases=[],
    name_mapping={
        "depends_on": "dependsOn",
        "for_each": "forEach",
        "providers": "providers",
        "skip_asset_creation_from_local_modules": "skipAssetCreationFromLocalModules",
    },
)
class TerraformModuleUserConfig:
    def __init__(
        self,
        *,
        depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
        for_each: typing.Optional[ITerraformIterator] = None,
        providers: typing.Optional[typing.Sequence[typing.Union["TerraformProvider", typing.Union[TerraformModuleProvider, typing.Dict[builtins.str, typing.Any]]]]] = None,
        skip_asset_creation_from_local_modules: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param depends_on: 
        :param for_each: 
        :param providers: 
        :param skip_asset_creation_from_local_modules: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a1aad1aec655a6400c69c9f245b7790ff2c2d7eed499fb5aa5c66082178e2ba1)
            check_type(argname="argument depends_on", value=depends_on, expected_type=type_hints["depends_on"])
            check_type(argname="argument for_each", value=for_each, expected_type=type_hints["for_each"])
            check_type(argname="argument providers", value=providers, expected_type=type_hints["providers"])
            check_type(argname="argument skip_asset_creation_from_local_modules", value=skip_asset_creation_from_local_modules, expected_type=type_hints["skip_asset_creation_from_local_modules"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if depends_on is not None:
            self._values["depends_on"] = depends_on
        if for_each is not None:
            self._values["for_each"] = for_each
        if providers is not None:
            self._values["providers"] = providers
        if skip_asset_creation_from_local_modules is not None:
            self._values["skip_asset_creation_from_local_modules"] = skip_asset_creation_from_local_modules

    @builtins.property
    def depends_on(self) -> typing.Optional[typing.List[ITerraformDependable]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("depends_on")
        return typing.cast(typing.Optional[typing.List[ITerraformDependable]], result)

    @builtins.property
    def for_each(self) -> typing.Optional[ITerraformIterator]:
        '''
        :stability: experimental
        '''
        result = self._values.get("for_each")
        return typing.cast(typing.Optional[ITerraformIterator], result)

    @builtins.property
    def providers(
        self,
    ) -> typing.Optional[typing.List[typing.Union["TerraformProvider", TerraformModuleProvider]]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("providers")
        return typing.cast(typing.Optional[typing.List[typing.Union["TerraformProvider", TerraformModuleProvider]]], result)

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


class TerraformOutput(
    TerraformElement,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.TerraformOutput",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        value: typing.Any,
        depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
        description: typing.Optional[builtins.str] = None,
        precondition: typing.Optional[typing.Union["Precondition", typing.Dict[builtins.str, typing.Any]]] = None,
        sensitive: typing.Optional[builtins.bool] = None,
        static_id: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param value: 
        :param depends_on: 
        :param description: 
        :param precondition: 
        :param sensitive: 
        :param static_id: (experimental) If set to true the synthesized Terraform Output will be named after the ``id`` passed to the constructor instead of the default (TerraformOutput.friendlyUniqueId). Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e2be71f636a5077e07a7c8520b67c6314531e050828228e087db0d1dbc07d878)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = TerraformOutputConfig(
            value=value,
            depends_on=depends_on,
            description=description,
            precondition=precondition,
            sensitive=sensitive,
            static_id=static_id,
        )

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

    @jsii.member(jsii_name="isTerraformOutput")
    @builtins.classmethod
    def is_terraform_output(cls, x: typing.Any) -> builtins.bool:
        '''
        :param x: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b171c7b35c78a7135ee8612adebc5f11dcb3fa834f6110e6dd5d32da04ad8107)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "isTerraformOutput", [x]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))

    @jsii.member(jsii_name="toHclTerraform")
    def to_hcl_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toHclTerraform", []))

    @jsii.member(jsii_name="toMetadata")
    def to_metadata(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toMetadata", []))

    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toTerraform", []))

    @builtins.property
    @jsii.member(jsii_name="staticId")
    def static_id(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "staticId"))

    @static_id.setter
    def static_id(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6b7bfcad8e947f6ca01ae1f36eb6e9f4400247d822ee40136e3c99167674cf13)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "staticId", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="value")
    def value(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.get(self, "value"))

    @value.setter
    def value(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8ff3667f921b567ade83fd674a10381d40e3919a7562df90e2b6b615c2cea4e5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "value", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="dependsOn")
    def depends_on(self) -> typing.Optional[typing.List[ITerraformDependable]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.List[ITerraformDependable]], jsii.get(self, "dependsOn"))

    @depends_on.setter
    def depends_on(
        self,
        value: typing.Optional[typing.List[ITerraformDependable]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d6c78adc9aadd2a9404b203d28ff9aee2dd3d59e6932409086d6308774bd9b88)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "dependsOn", value) # pyright: ignore[reportArgumentType]

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

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aa3846fea41559cc28ca23bd1e6ddafe9dfd7b112b564eca0753dd240c0bf2ab)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="precondition")
    def precondition(self) -> typing.Optional["Precondition"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional["Precondition"], jsii.get(self, "precondition"))

    @precondition.setter
    def precondition(self, value: typing.Optional["Precondition"]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__895ff9c2f7bb242c2ee0dd45d919efe8c00d32716f5ba1fc2f2e4121efa744e6)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "precondition", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="sensitive")
    def sensitive(self) -> typing.Optional[builtins.bool]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "sensitive"))

    @sensitive.setter
    def sensitive(self, value: typing.Optional[builtins.bool]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1803c21388d9fa6d99a9b89f40235e5e446d414e5ff323ec7f82ab9f83faf42a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sensitive", value) # pyright: ignore[reportArgumentType]


@jsii.data_type(
    jsii_type="cdktn.TerraformOutputConfig",
    jsii_struct_bases=[],
    name_mapping={
        "value": "value",
        "depends_on": "dependsOn",
        "description": "description",
        "precondition": "precondition",
        "sensitive": "sensitive",
        "static_id": "staticId",
    },
)
class TerraformOutputConfig:
    def __init__(
        self,
        *,
        value: typing.Any,
        depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
        description: typing.Optional[builtins.str] = None,
        precondition: typing.Optional[typing.Union["Precondition", typing.Dict[builtins.str, typing.Any]]] = None,
        sensitive: typing.Optional[builtins.bool] = None,
        static_id: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param value: 
        :param depends_on: 
        :param description: 
        :param precondition: 
        :param sensitive: 
        :param static_id: (experimental) If set to true the synthesized Terraform Output will be named after the ``id`` passed to the constructor instead of the default (TerraformOutput.friendlyUniqueId). Default: false

        :stability: experimental
        '''
        if isinstance(precondition, dict):
            precondition = Precondition(**precondition)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aea7829b6c6337c700fffa9d1d1fb383b28e53c8d21cf1f575fba53b839d37e2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
            check_type(argname="argument depends_on", value=depends_on, expected_type=type_hints["depends_on"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument precondition", value=precondition, expected_type=type_hints["precondition"])
            check_type(argname="argument sensitive", value=sensitive, expected_type=type_hints["sensitive"])
            check_type(argname="argument static_id", value=static_id, expected_type=type_hints["static_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "value": value,
        }
        if depends_on is not None:
            self._values["depends_on"] = depends_on
        if description is not None:
            self._values["description"] = description
        if precondition is not None:
            self._values["precondition"] = precondition
        if sensitive is not None:
            self._values["sensitive"] = sensitive
        if static_id is not None:
            self._values["static_id"] = static_id

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

    @builtins.property
    def depends_on(self) -> typing.Optional[typing.List[ITerraformDependable]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("depends_on")
        return typing.cast(typing.Optional[typing.List[ITerraformDependable]], result)

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

    @builtins.property
    def precondition(self) -> typing.Optional["Precondition"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("precondition")
        return typing.cast(typing.Optional["Precondition"], result)

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

    @builtins.property
    def static_id(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If set to true the synthesized Terraform Output will be named after the ``id`` passed to the constructor instead of the default (TerraformOutput.friendlyUniqueId).

        :default: false

        :stability: experimental
        '''
        result = self._values.get("static_id")
        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 "TerraformOutputConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class TerraformProvider(
    TerraformElement,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="cdktn.TerraformProvider",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        terraform_resource_type: builtins.str,
        terraform_generator_metadata: typing.Optional[typing.Union["TerraformProviderGeneratorMetadata", typing.Dict[builtins.str, typing.Any]]] = None,
        terraform_provider_source: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param terraform_resource_type: 
        :param terraform_generator_metadata: 
        :param terraform_provider_source: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f29ec5ee8fe90fcc2799b8475a18640147d6197734a045cbca786bd1022b1893)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = TerraformProviderConfig(
            terraform_resource_type=terraform_resource_type,
            terraform_generator_metadata=terraform_generator_metadata,
            terraform_provider_source=terraform_provider_source,
        )

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

    @jsii.member(jsii_name="isTerraformProvider")
    @builtins.classmethod
    def is_terraform_provider(cls, x: typing.Any) -> builtins.bool:
        '''
        :param x: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4fc04dea9e581a8742d8aec1907fc2d0de1a885c456083be46d4a774072f9b4a)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "isTerraformProvider", [x]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))

    @jsii.member(jsii_name="toHclTerraform")
    def to_hcl_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toHclTerraform", []))

    @jsii.member(jsii_name="toMetadata")
    def to_metadata(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toMetadata", []))

    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> typing.Any:
        '''(experimental) Adds this resource to the terraform JSON output.

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toTerraform", []))

    @builtins.property
    @jsii.member(jsii_name="fqn")
    def fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "fqn"))

    @builtins.property
    @jsii.member(jsii_name="metaAttributes")
    def meta_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "metaAttributes"))

    @builtins.property
    @jsii.member(jsii_name="terraformResourceType")
    def terraform_resource_type(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformResourceType"))

    @builtins.property
    @jsii.member(jsii_name="terraformGeneratorMetadata")
    def terraform_generator_metadata(
        self,
    ) -> typing.Optional["TerraformProviderGeneratorMetadata"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional["TerraformProviderGeneratorMetadata"], jsii.get(self, "terraformGeneratorMetadata"))

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

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

    @alias.setter
    def alias(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__456e906543548a5337cf60b23057ce623965903cebe176cd9056d7f26a7ff6df)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "alias", value) # pyright: ignore[reportArgumentType]


class _TerraformProviderProxy(TerraformProvider):
    pass

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


@jsii.data_type(
    jsii_type="cdktn.TerraformProviderConfig",
    jsii_struct_bases=[],
    name_mapping={
        "terraform_resource_type": "terraformResourceType",
        "terraform_generator_metadata": "terraformGeneratorMetadata",
        "terraform_provider_source": "terraformProviderSource",
    },
)
class TerraformProviderConfig:
    def __init__(
        self,
        *,
        terraform_resource_type: builtins.str,
        terraform_generator_metadata: typing.Optional[typing.Union["TerraformProviderGeneratorMetadata", typing.Dict[builtins.str, typing.Any]]] = None,
        terraform_provider_source: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param terraform_resource_type: 
        :param terraform_generator_metadata: 
        :param terraform_provider_source: 

        :stability: experimental
        '''
        if isinstance(terraform_generator_metadata, dict):
            terraform_generator_metadata = TerraformProviderGeneratorMetadata(**terraform_generator_metadata)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dd0ea1226e835522ba6118a50a3b6a2cc014e1d1ecace13f39dd2979e0e271b4)
            check_type(argname="argument terraform_resource_type", value=terraform_resource_type, expected_type=type_hints["terraform_resource_type"])
            check_type(argname="argument terraform_generator_metadata", value=terraform_generator_metadata, expected_type=type_hints["terraform_generator_metadata"])
            check_type(argname="argument terraform_provider_source", value=terraform_provider_source, expected_type=type_hints["terraform_provider_source"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "terraform_resource_type": terraform_resource_type,
        }
        if terraform_generator_metadata is not None:
            self._values["terraform_generator_metadata"] = terraform_generator_metadata
        if terraform_provider_source is not None:
            self._values["terraform_provider_source"] = terraform_provider_source

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

    @builtins.property
    def terraform_generator_metadata(
        self,
    ) -> typing.Optional["TerraformProviderGeneratorMetadata"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("terraform_generator_metadata")
        return typing.cast(typing.Optional["TerraformProviderGeneratorMetadata"], result)

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


@jsii.data_type(
    jsii_type="cdktn.TerraformProviderGeneratorMetadata",
    jsii_struct_bases=[],
    name_mapping={
        "provider_name": "providerName",
        "provider_version": "providerVersion",
        "provider_version_constraint": "providerVersionConstraint",
    },
)
class TerraformProviderGeneratorMetadata:
    def __init__(
        self,
        *,
        provider_name: builtins.str,
        provider_version: typing.Optional[builtins.str] = None,
        provider_version_constraint: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param provider_name: 
        :param provider_version: 
        :param provider_version_constraint: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bcf3c96e47fcb9a54b8e7530163181b552b200de16ecc246811b468838978bda)
            check_type(argname="argument provider_name", value=provider_name, expected_type=type_hints["provider_name"])
            check_type(argname="argument provider_version", value=provider_version, expected_type=type_hints["provider_version"])
            check_type(argname="argument provider_version_constraint", value=provider_version_constraint, expected_type=type_hints["provider_version_constraint"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "provider_name": provider_name,
        }
        if provider_version is not None:
            self._values["provider_version"] = provider_version
        if provider_version_constraint is not None:
            self._values["provider_version_constraint"] = provider_version_constraint

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

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

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


@jsii.implements(ITerraformAddressable)
class TerraformRemoteState(
    TerraformElement,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="cdktn.TerraformRemoteState",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        backend: builtins.str,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param backend: -
        :param defaults: 
        :param workspace: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1276fbe4187f97c166701a3d26700c3c7256ed52c628568aa721f9b2c3585bb9)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument backend", value=backend, expected_type=type_hints["backend"])
        config = DataTerraformRemoteStateConfig(defaults=defaults, workspace=workspace)

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

    @jsii.member(jsii_name="get")
    def get(self, output: builtins.str) -> IResolvable:
        '''
        :param output: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6dc989d8f4c6f626b660ce2f628d1f55e224f369a3977d5deaee88d99a39d9d6)
            check_type(argname="argument output", value=output, expected_type=type_hints["output"])
        return typing.cast(IResolvable, jsii.invoke(self, "get", [output]))

    @jsii.member(jsii_name="getBoolean")
    def get_boolean(self, output: builtins.str) -> IResolvable:
        '''
        :param output: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__61c8d07530662166ed5dd70e0517a0d6ed9dbb066ab45a36e507f1b84533526c)
            check_type(argname="argument output", value=output, expected_type=type_hints["output"])
        return typing.cast(IResolvable, jsii.invoke(self, "getBoolean", [output]))

    @jsii.member(jsii_name="getList")
    def get_list(self, output: builtins.str) -> typing.List[builtins.str]:
        '''
        :param output: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__624a9336467e5f048b0c2f334780c757386cbf73b996c28a47d191c911b3b900)
            check_type(argname="argument output", value=output, expected_type=type_hints["output"])
        return typing.cast(typing.List[builtins.str], jsii.invoke(self, "getList", [output]))

    @jsii.member(jsii_name="getNumber")
    def get_number(self, output: builtins.str) -> jsii.Number:
        '''
        :param output: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5908b12f00a6870066cf2612e45add0d132587a1fb4e6bc32e9181907930ca91)
            check_type(argname="argument output", value=output, expected_type=type_hints["output"])
        return typing.cast(jsii.Number, jsii.invoke(self, "getNumber", [output]))

    @jsii.member(jsii_name="getString")
    def get_string(self, output: builtins.str) -> builtins.str:
        '''
        :param output: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3a285a9105ee693e7cf1abb368f3a40dc075c81403dbb81f793da04765b408ec)
            check_type(argname="argument output", value=output, expected_type=type_hints["output"])
        return typing.cast(builtins.str, jsii.invoke(self, "getString", [output]))

    @jsii.member(jsii_name="toHclTerraform")
    def to_hcl_terraform(self) -> typing.Any:
        '''(experimental) Adds this resource to the terraform JSON output.

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toHclTerraform", []))

    @jsii.member(jsii_name="toMetadata")
    def to_metadata(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toMetadata", []))

    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> typing.Any:
        '''(experimental) Adds this resource to the terraform JSON output.

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toTerraform", []))

    @jsii.python.classproperty
    @jsii.member(jsii_name="tfResourceType")
    def TF_RESOURCE_TYPE(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "tfResourceType"))


class _TerraformRemoteStateProxy(TerraformRemoteState):
    pass

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


@jsii.implements(ITerraformResource, ITerraformDependable, IInterpolatingParent)
class TerraformResource(
    TerraformElement,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.TerraformResource",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        terraform_resource_type: builtins.str,
        terraform_generator_metadata: typing.Optional[typing.Union[TerraformProviderGeneratorMetadata, typing.Dict[builtins.str, typing.Any]]] = None,
        connection: typing.Optional[typing.Union[typing.Union[SSHProvisionerConnection, typing.Dict[builtins.str, typing.Any]], typing.Union["WinrmProvisionerConnection", typing.Dict[builtins.str, typing.Any]]]] = None,
        count: typing.Optional[typing.Union[jsii.Number, TerraformCount]] = None,
        depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
        for_each: typing.Optional[ITerraformIterator] = None,
        lifecycle: typing.Optional[typing.Union["TerraformResourceLifecycle", typing.Dict[builtins.str, typing.Any]]] = None,
        provider: typing.Optional[TerraformProvider] = None,
        provisioners: typing.Optional[typing.Sequence[typing.Union[typing.Union[FileProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[LocalExecProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[RemoteExecProvisioner, typing.Dict[builtins.str, typing.Any]]]]] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param terraform_resource_type: 
        :param terraform_generator_metadata: 
        :param connection: 
        :param count: 
        :param depends_on: 
        :param for_each: 
        :param lifecycle: 
        :param provider: 
        :param provisioners: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d1ea2897bc4eed1005d89529a05c9509ef3e64dfa89ada96dfc7a64fecfd1351)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = TerraformResourceConfig(
            terraform_resource_type=terraform_resource_type,
            terraform_generator_metadata=terraform_generator_metadata,
            connection=connection,
            count=count,
            depends_on=depends_on,
            for_each=for_each,
            lifecycle=lifecycle,
            provider=provider,
            provisioners=provisioners,
        )

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

    @jsii.member(jsii_name="isTerraformResource")
    @builtins.classmethod
    def is_terraform_resource(cls, x: typing.Any) -> builtins.bool:
        '''
        :param x: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__215ab21290894e9bba753ea4baa29eb2592399af5b9bcb2d853052a953af82b2)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "isTerraformResource", [x]))

    @jsii.member(jsii_name="addMoveTarget")
    def add_move_target(self, move_target: builtins.str) -> None:
        '''(experimental) Adds a user defined moveTarget string to this resource to be later used in .moveTo(moveTarget) to resolve the location of the move.

        :param move_target: The string move target that will correspond to this resource.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6f7d58e634b75d866454f3d7cfe9a1b337e6431d6dd93859da0c137db16de724)
            check_type(argname="argument move_target", value=move_target, expected_type=type_hints["move_target"])
        return typing.cast(None, jsii.invoke(self, "addMoveTarget", [move_target]))

    @jsii.member(jsii_name="getAnyMapAttribute")
    def get_any_map_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__71fe2f8ad07828de1a2a5a0ac1e2aab92554268db4f0c67fdd7358b16bda7111)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "getAnyMapAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getBooleanAttribute")
    def get_boolean_attribute(self, terraform_attribute: builtins.str) -> IResolvable:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__61d4a6727decc3d1e8aca0ed39d2d776570234c24cbfd9f11e05bb04b5802749)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(IResolvable, jsii.invoke(self, "getBooleanAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getBooleanMapAttribute")
    def get_boolean_map_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, builtins.bool]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7039bcddefc8fc4754b9f956e7eb4fc7ff69f308cf8870b1bebf6fac6901bef0)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.Mapping[builtins.str, builtins.bool], jsii.invoke(self, "getBooleanMapAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getListAttribute")
    def get_list_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.List[builtins.str]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__38f632aa3df631867c92eab32fa57be5ef5e2798e296939908c0384e39e16cd1)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.List[builtins.str], jsii.invoke(self, "getListAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getNumberAttribute")
    def get_number_attribute(self, terraform_attribute: builtins.str) -> jsii.Number:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a6cf359fcecc8d4dc1b50d80c840d0c5d50bf5c92a0f8888b642ff0b30c6c3e4)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(jsii.Number, jsii.invoke(self, "getNumberAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getNumberListAttribute")
    def get_number_list_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.List[jsii.Number]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d996bd49d7ccb1e05da24c2a765c90a6ff1757f37ff84a236c5965ba6bef130c)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.List[jsii.Number], jsii.invoke(self, "getNumberListAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getNumberMapAttribute")
    def get_number_map_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, jsii.Number]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0960e8c78ae603fbee208f9c04c9bcd868b2cc3ac95ef777e773885c09bc4933)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.Mapping[builtins.str, jsii.Number], jsii.invoke(self, "getNumberMapAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getStringAttribute")
    def get_string_attribute(self, terraform_attribute: builtins.str) -> builtins.str:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f7fac00656393b1197021bd8c4039f9cb11aee473646d86717b610cc732f5f83)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(builtins.str, jsii.invoke(self, "getStringAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getStringMapAttribute")
    def get_string_map_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__23e4db389600107ebb9296c22bc0007605bf434b0ea027e55d90b14a4b956316)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.invoke(self, "getStringMapAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="hasResourceMove")
    def has_resource_move(
        self,
    ) -> typing.Optional[typing.Union["TerraformResourceMoveByTarget", "TerraformResourceMoveById"]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union["TerraformResourceMoveByTarget", "TerraformResourceMoveById"]], jsii.invoke(self, "hasResourceMove", []))

    @jsii.member(jsii_name="importFrom")
    def import_from(
        self,
        id: builtins.str,
        provider: typing.Optional[TerraformProvider] = None,
    ) -> None:
        '''
        :param id: -
        :param provider: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d2f3e263f8c68f23cc9c5efc4581cf7cf544ba047f89df517b1543688e7b9ea3)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument provider", value=provider, expected_type=type_hints["provider"])
        return typing.cast(None, jsii.invoke(self, "importFrom", [id, provider]))

    @jsii.member(jsii_name="interpolationForAttribute")
    def interpolation_for_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> IResolvable:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__544087f0479b5aa070c21921656767002f5fb731cd940179b26efdffabd48c71)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(IResolvable, jsii.invoke(self, "interpolationForAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="moveFromId")
    def move_from_id(self, id: builtins.str) -> None:
        '''(experimental) Move the resource corresponding to "id" to this resource.

        Note that the resource being moved from must be marked as moved using it's instance function.

        :param id: Full id of resource being moved from, e.g. "aws_s3_bucket.example".

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3256f5b856d6201793f7b30bfa0a61724858a93346387d6d02c18f17c1475628)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        return typing.cast(None, jsii.invoke(self, "moveFromId", [id]))

    @jsii.member(jsii_name="moveTo")
    def move_to(
        self,
        move_target: builtins.str,
        index: typing.Optional[typing.Union[builtins.str, jsii.Number]] = None,
    ) -> None:
        '''(experimental) Moves this resource to the target resource given by moveTarget.

        :param move_target: The previously set user defined string set by .addMoveTarget() corresponding to the resource to move to.
        :param index: Optional The index corresponding to the key the resource is to appear in the foreach of a resource to move to.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ba688420b4b64efb0d932319bf4d5b192ee42ff73b4aa2dc6620dd8aeb31cbe5)
            check_type(argname="argument move_target", value=move_target, expected_type=type_hints["move_target"])
            check_type(argname="argument index", value=index, expected_type=type_hints["index"])
        return typing.cast(None, jsii.invoke(self, "moveTo", [move_target, index]))

    @jsii.member(jsii_name="moveToId")
    def move_to_id(self, id: builtins.str) -> None:
        '''(experimental) Moves this resource to the resource corresponding to "id".

        :param id: Full id of resource to move to, e.g. "aws_s3_bucket.example".

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d2d2bdf5c22152ee0baaacf81a6087a807cb8670bacbd074d12636be6a0b9619)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        return typing.cast(None, jsii.invoke(self, "moveToId", [id]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))

    @jsii.member(jsii_name="toHclTerraform")
    def to_hcl_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toHclTerraform", []))

    @jsii.member(jsii_name="toMetadata")
    def to_metadata(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toMetadata", []))

    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> typing.Any:
        '''(experimental) Adds this resource to the terraform JSON output.

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toTerraform", []))

    @builtins.property
    @jsii.member(jsii_name="terraformMetaArguments")
    def terraform_meta_arguments(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "terraformMetaArguments"))

    @builtins.property
    @jsii.member(jsii_name="terraformResourceType")
    def terraform_resource_type(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformResourceType"))

    @builtins.property
    @jsii.member(jsii_name="terraformGeneratorMetadata")
    def terraform_generator_metadata(
        self,
    ) -> typing.Optional[TerraformProviderGeneratorMetadata]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[TerraformProviderGeneratorMetadata], jsii.get(self, "terraformGeneratorMetadata"))

    @builtins.property
    @jsii.member(jsii_name="connection")
    def connection(
        self,
    ) -> typing.Optional[typing.Union[SSHProvisionerConnection, "WinrmProvisionerConnection"]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[SSHProvisionerConnection, "WinrmProvisionerConnection"]], jsii.get(self, "connection"))

    @connection.setter
    def connection(
        self,
        value: typing.Optional[typing.Union[SSHProvisionerConnection, "WinrmProvisionerConnection"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__435ff282656e4cf599f62153039ccd6c8d608af766877be8e47563123f57baa1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "connection", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="count")
    def count(self) -> typing.Optional[typing.Union[jsii.Number, TerraformCount]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[jsii.Number, TerraformCount]], jsii.get(self, "count"))

    @count.setter
    def count(
        self,
        value: typing.Optional[typing.Union[jsii.Number, TerraformCount]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bc1497fc0f2d401bb98674c41c6176895f98a0f2659b72d1f3538da0223e2d4b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "count", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="dependsOn")
    def depends_on(self) -> typing.Optional[typing.List[builtins.str]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "dependsOn"))

    @depends_on.setter
    def depends_on(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7ab06c371f7bcbea1830dd4340375686c19fcb8b11532b60c52b97aefab9c679)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "dependsOn", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="forEach")
    def for_each(self) -> typing.Optional[ITerraformIterator]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[ITerraformIterator], jsii.get(self, "forEach"))

    @for_each.setter
    def for_each(self, value: typing.Optional[ITerraformIterator]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3b4c7e3415d903363aba287c646ee6141721e5466f5422d772f5cedaa815510e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "forEach", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="lifecycle")
    def lifecycle(self) -> typing.Optional["TerraformResourceLifecycle"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional["TerraformResourceLifecycle"], jsii.get(self, "lifecycle"))

    @lifecycle.setter
    def lifecycle(self, value: typing.Optional["TerraformResourceLifecycle"]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__44f9846bcf16b921c668f2a412e911da8493a63fb63b6ff727bcc3d306535a9b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "lifecycle", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="provider")
    def provider(self) -> typing.Optional[TerraformProvider]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[TerraformProvider], jsii.get(self, "provider"))

    @provider.setter
    def provider(self, value: typing.Optional[TerraformProvider]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__da09c5c8a464d6ecefc038b43812a9beb24e745ce5e2e3ffb1c7db834757e65d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "provider", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="provisioners")
    def provisioners(
        self,
    ) -> typing.Optional[typing.List[typing.Union[FileProvisioner, LocalExecProvisioner, RemoteExecProvisioner]]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.List[typing.Union[FileProvisioner, LocalExecProvisioner, RemoteExecProvisioner]]], jsii.get(self, "provisioners"))

    @provisioners.setter
    def provisioners(
        self,
        value: typing.Optional[typing.List[typing.Union[FileProvisioner, LocalExecProvisioner, RemoteExecProvisioner]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__97e0091145c8cb81cafc1be6eb746bd9872b36e2d9f2d7c6ed0286f7d281dd01)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "provisioners", value) # pyright: ignore[reportArgumentType]


@jsii.data_type(
    jsii_type="cdktn.TerraformResourceConfig",
    jsii_struct_bases=[TerraformMetaArguments],
    name_mapping={
        "connection": "connection",
        "count": "count",
        "depends_on": "dependsOn",
        "for_each": "forEach",
        "lifecycle": "lifecycle",
        "provider": "provider",
        "provisioners": "provisioners",
        "terraform_resource_type": "terraformResourceType",
        "terraform_generator_metadata": "terraformGeneratorMetadata",
    },
)
class TerraformResourceConfig(TerraformMetaArguments):
    def __init__(
        self,
        *,
        connection: typing.Optional[typing.Union[typing.Union[SSHProvisionerConnection, typing.Dict[builtins.str, typing.Any]], typing.Union["WinrmProvisionerConnection", typing.Dict[builtins.str, typing.Any]]]] = None,
        count: typing.Optional[typing.Union[jsii.Number, TerraformCount]] = None,
        depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
        for_each: typing.Optional[ITerraformIterator] = None,
        lifecycle: typing.Optional[typing.Union["TerraformResourceLifecycle", typing.Dict[builtins.str, typing.Any]]] = None,
        provider: typing.Optional[TerraformProvider] = None,
        provisioners: typing.Optional[typing.Sequence[typing.Union[typing.Union[FileProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[LocalExecProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[RemoteExecProvisioner, typing.Dict[builtins.str, typing.Any]]]]] = None,
        terraform_resource_type: builtins.str,
        terraform_generator_metadata: typing.Optional[typing.Union[TerraformProviderGeneratorMetadata, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param connection: 
        :param count: 
        :param depends_on: 
        :param for_each: 
        :param lifecycle: 
        :param provider: 
        :param provisioners: 
        :param terraform_resource_type: 
        :param terraform_generator_metadata: 

        :stability: experimental
        '''
        if isinstance(lifecycle, dict):
            lifecycle = TerraformResourceLifecycle(**lifecycle)
        if isinstance(terraform_generator_metadata, dict):
            terraform_generator_metadata = TerraformProviderGeneratorMetadata(**terraform_generator_metadata)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__45bbb555f892f64b72e5b78f4bfa51082b771111b6e05a0ecbacb18e24b2bb84)
            check_type(argname="argument connection", value=connection, expected_type=type_hints["connection"])
            check_type(argname="argument count", value=count, expected_type=type_hints["count"])
            check_type(argname="argument depends_on", value=depends_on, expected_type=type_hints["depends_on"])
            check_type(argname="argument for_each", value=for_each, expected_type=type_hints["for_each"])
            check_type(argname="argument lifecycle", value=lifecycle, expected_type=type_hints["lifecycle"])
            check_type(argname="argument provider", value=provider, expected_type=type_hints["provider"])
            check_type(argname="argument provisioners", value=provisioners, expected_type=type_hints["provisioners"])
            check_type(argname="argument terraform_resource_type", value=terraform_resource_type, expected_type=type_hints["terraform_resource_type"])
            check_type(argname="argument terraform_generator_metadata", value=terraform_generator_metadata, expected_type=type_hints["terraform_generator_metadata"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "terraform_resource_type": terraform_resource_type,
        }
        if connection is not None:
            self._values["connection"] = connection
        if count is not None:
            self._values["count"] = count
        if depends_on is not None:
            self._values["depends_on"] = depends_on
        if for_each is not None:
            self._values["for_each"] = for_each
        if lifecycle is not None:
            self._values["lifecycle"] = lifecycle
        if provider is not None:
            self._values["provider"] = provider
        if provisioners is not None:
            self._values["provisioners"] = provisioners
        if terraform_generator_metadata is not None:
            self._values["terraform_generator_metadata"] = terraform_generator_metadata

    @builtins.property
    def connection(
        self,
    ) -> typing.Optional[typing.Union[SSHProvisionerConnection, "WinrmProvisionerConnection"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("connection")
        return typing.cast(typing.Optional[typing.Union[SSHProvisionerConnection, "WinrmProvisionerConnection"]], result)

    @builtins.property
    def count(self) -> typing.Optional[typing.Union[jsii.Number, TerraformCount]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("count")
        return typing.cast(typing.Optional[typing.Union[jsii.Number, TerraformCount]], result)

    @builtins.property
    def depends_on(self) -> typing.Optional[typing.List[ITerraformDependable]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("depends_on")
        return typing.cast(typing.Optional[typing.List[ITerraformDependable]], result)

    @builtins.property
    def for_each(self) -> typing.Optional[ITerraformIterator]:
        '''
        :stability: experimental
        '''
        result = self._values.get("for_each")
        return typing.cast(typing.Optional[ITerraformIterator], result)

    @builtins.property
    def lifecycle(self) -> typing.Optional["TerraformResourceLifecycle"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("lifecycle")
        return typing.cast(typing.Optional["TerraformResourceLifecycle"], result)

    @builtins.property
    def provider(self) -> typing.Optional[TerraformProvider]:
        '''
        :stability: experimental
        '''
        result = self._values.get("provider")
        return typing.cast(typing.Optional[TerraformProvider], result)

    @builtins.property
    def provisioners(
        self,
    ) -> typing.Optional[typing.List[typing.Union[FileProvisioner, LocalExecProvisioner, RemoteExecProvisioner]]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("provisioners")
        return typing.cast(typing.Optional[typing.List[typing.Union[FileProvisioner, LocalExecProvisioner, RemoteExecProvisioner]]], result)

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

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


@jsii.data_type(
    jsii_type="cdktn.TerraformResourceImport",
    jsii_struct_bases=[],
    name_mapping={"id": "id", "provider": "provider"},
)
class TerraformResourceImport:
    def __init__(
        self,
        *,
        id: builtins.str,
        provider: typing.Optional[TerraformProvider] = None,
    ) -> None:
        '''
        :param id: 
        :param provider: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__85e7052f901655028aa9095e8bd03e504ea17544341294c06021c0167be1f33d)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument provider", value=provider, expected_type=type_hints["provider"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "id": id,
        }
        if provider is not None:
            self._values["provider"] = provider

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

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


@jsii.data_type(
    jsii_type="cdktn.TerraformResourceLifecycle",
    jsii_struct_bases=[],
    name_mapping={
        "create_before_destroy": "createBeforeDestroy",
        "ignore_changes": "ignoreChanges",
        "postcondition": "postcondition",
        "precondition": "precondition",
        "prevent_destroy": "preventDestroy",
        "replace_triggered_by": "replaceTriggeredBy",
    },
)
class TerraformResourceLifecycle:
    def __init__(
        self,
        *,
        create_before_destroy: typing.Optional[builtins.bool] = None,
        ignore_changes: typing.Optional[typing.Union[typing.Sequence[builtins.str], builtins.str]] = None,
        postcondition: typing.Optional[typing.Sequence[typing.Union["Postcondition", typing.Dict[builtins.str, typing.Any]]]] = None,
        precondition: typing.Optional[typing.Sequence[typing.Union["Precondition", typing.Dict[builtins.str, typing.Any]]]] = None,
        prevent_destroy: typing.Optional[builtins.bool] = None,
        replace_triggered_by: typing.Optional[typing.Sequence[typing.Union[builtins.str, ITerraformDependable]]] = None,
    ) -> None:
        '''
        :param create_before_destroy: 
        :param ignore_changes: 
        :param postcondition: 
        :param precondition: 
        :param prevent_destroy: 
        :param replace_triggered_by: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__407af3a931e3f84f33b666437dafcdf0ddc238de72b1b2b2a672009ed577428e)
            check_type(argname="argument create_before_destroy", value=create_before_destroy, expected_type=type_hints["create_before_destroy"])
            check_type(argname="argument ignore_changes", value=ignore_changes, expected_type=type_hints["ignore_changes"])
            check_type(argname="argument postcondition", value=postcondition, expected_type=type_hints["postcondition"])
            check_type(argname="argument precondition", value=precondition, expected_type=type_hints["precondition"])
            check_type(argname="argument prevent_destroy", value=prevent_destroy, expected_type=type_hints["prevent_destroy"])
            check_type(argname="argument replace_triggered_by", value=replace_triggered_by, expected_type=type_hints["replace_triggered_by"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if create_before_destroy is not None:
            self._values["create_before_destroy"] = create_before_destroy
        if ignore_changes is not None:
            self._values["ignore_changes"] = ignore_changes
        if postcondition is not None:
            self._values["postcondition"] = postcondition
        if precondition is not None:
            self._values["precondition"] = precondition
        if prevent_destroy is not None:
            self._values["prevent_destroy"] = prevent_destroy
        if replace_triggered_by is not None:
            self._values["replace_triggered_by"] = replace_triggered_by

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

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

    @builtins.property
    def postcondition(self) -> typing.Optional[typing.List["Postcondition"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("postcondition")
        return typing.cast(typing.Optional[typing.List["Postcondition"]], result)

    @builtins.property
    def precondition(self) -> typing.Optional[typing.List["Precondition"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("precondition")
        return typing.cast(typing.Optional[typing.List["Precondition"]], result)

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

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


@jsii.data_type(
    jsii_type="cdktn.TerraformResourceMoveById",
    jsii_struct_bases=[],
    name_mapping={"from_": "from", "to": "to"},
)
class TerraformResourceMoveById:
    def __init__(self, *, from_: builtins.str, to: builtins.str) -> None:
        '''
        :param from_: 
        :param to: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e6b8d99bc04769656865aa6976feb6c7059ae0425113fbbbb875de3a3c6efd9d)
            check_type(argname="argument from_", value=from_, expected_type=type_hints["from_"])
            check_type(argname="argument to", value=to, expected_type=type_hints["to"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "from_": from_,
            "to": to,
        }

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

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


@jsii.data_type(
    jsii_type="cdktn.TerraformResourceMoveByTarget",
    jsii_struct_bases=[],
    name_mapping={"move_target": "moveTarget", "index": "index"},
)
class TerraformResourceMoveByTarget:
    def __init__(
        self,
        *,
        move_target: builtins.str,
        index: typing.Optional[typing.Union[builtins.str, jsii.Number]] = None,
    ) -> None:
        '''
        :param move_target: 
        :param index: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f8ead29bd3d21868f42eef51ed5bcfdb0c37ac7b55439f9fb9b77e46d6a6ea35)
            check_type(argname="argument move_target", value=move_target, expected_type=type_hints["move_target"])
            check_type(argname="argument index", value=index, expected_type=type_hints["index"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "move_target": move_target,
        }
        if index is not None:
            self._values["index"] = index

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

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


class TerraformResourceTargets(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.TerraformResourceTargets",
):
    '''
    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="addResourceTarget")
    def add_resource_target(
        self,
        resource: TerraformResource,
        target: builtins.str,
    ) -> None:
        '''
        :param resource: -
        :param target: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a21400d80314ed3e958ef76e30a4efef48e7ad08ce4bf6288b9bd5a96e2bf17b)
            check_type(argname="argument resource", value=resource, expected_type=type_hints["resource"])
            check_type(argname="argument target", value=target, expected_type=type_hints["target"])
        return typing.cast(None, jsii.invoke(self, "addResourceTarget", [resource, target]))

    @jsii.member(jsii_name="getResourceByTarget")
    def get_resource_by_target(self, target: builtins.str) -> TerraformResource:
        '''
        :param target: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e7aa15d10ab59dd1cfa68892d8e7d241aeac16a0fc827968eb5556df3afd5b5f)
            check_type(argname="argument target", value=target, expected_type=type_hints["target"])
        return typing.cast(TerraformResource, jsii.invoke(self, "getResourceByTarget", [target]))


class TerraformSelf(metaclass=jsii.JSIIMeta, jsii_type="cdktn.TerraformSelf"):
    '''(experimental) Expressions in connection blocks cannot refer to their parent resource by name.

    References create dependencies, and referring to a resource by name within its own block would create a dependency cycle.
    Instead, expressions can use the self object, which represents the connection's parent resource and has all of that resource's attributes.
    For example, use self.public_ip to reference an aws_instance's public_ip attribute.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="getAny")
    @builtins.classmethod
    def get_any(cls, key: builtins.str) -> typing.Any:
        '''(experimental) Only usable within a connection block to reference the connections parent resource.

        Access a property on the resource like this: ``getAny("hostPort")``

        :param key: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bb1dadbae03e6a88cd10d06fdb475424de819ff603a764827afafceae6d45fcc)
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "getAny", [key]))

    @jsii.member(jsii_name="getNumber")
    @builtins.classmethod
    def get_number(cls, key: builtins.str) -> jsii.Number:
        '''(experimental) Only usable within a connection block to reference the connections parent resource.

        Access a property on the resource like this: ``getNumber("hostPort")``

        :param key: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d339df03fc87fb94e5fe27df2bb0b66a7bb1318488a97a4679a66febeb586613)
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "getNumber", [key]))

    @jsii.member(jsii_name="getString")
    @builtins.classmethod
    def get_string(cls, key: builtins.str) -> builtins.str:
        '''(experimental) Only usable within a connection block to reference the connections parent resource.

        Access a property on the resource like this: ``getString("publicIp")``

        :param key: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__202e8441a6435eb402c6d4a3625d9f729b199f2001cdd252cc516da80dd3a3c7)
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "getString", [key]))


class TerraformStack(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.TerraformStack",
):
    '''
    :stability: experimental
    '''

    def __init__(self, scope: _constructs_77d1e7e8.Construct, id: builtins.str) -> None:
        '''
        :param scope: -
        :param id: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fe7cc9c0f474a20ab351b91bb1ff24294da15565cdbe837b0a39aedb3906d46d)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        jsii.create(self.__class__, self, [scope, id])

    @jsii.member(jsii_name="isStack")
    @builtins.classmethod
    def is_stack(cls, x: typing.Any) -> builtins.bool:
        '''
        :param x: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b3cc1266d71e18b813a55365caebc38c0e6313689418721ee237e1e149f23aea)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "isStack", [x]))

    @jsii.member(jsii_name="of")
    @builtins.classmethod
    def of(cls, construct: _constructs_77d1e7e8.IConstruct) -> "TerraformStack":
        '''
        :param construct: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0f4ad6425136b110fcc986547778f2da43ba6a96b54ccd9618ded5433842ee25)
            check_type(argname="argument construct", value=construct, expected_type=type_hints["construct"])
        return typing.cast("TerraformStack", jsii.sinvoke(cls, "of", [construct]))

    @jsii.member(jsii_name="addDependency")
    def add_dependency(self, dependency: "TerraformStack") -> None:
        '''
        :param dependency: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7c596bcaca4f08b39ab9b69ad0bbf8713401da56876faa310aaee1786868e68e)
            check_type(argname="argument dependency", value=dependency, expected_type=type_hints["dependency"])
        return typing.cast(None, jsii.invoke(self, "addDependency", [dependency]))

    @jsii.member(jsii_name="addOverride")
    def add_override(self, path: builtins.str, value: typing.Any) -> None:
        '''
        :param path: -
        :param value: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__983a7759871db826f7849b3ec538ca23e46963f9d5f001c080a5c8a0f89dfa34)
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        return typing.cast(None, jsii.invoke(self, "addOverride", [path, value]))

    @jsii.member(jsii_name="allocateLogicalId")
    def _allocate_logical_id(
        self,
        tf_element: typing.Union[_constructs_77d1e7e8.Node, TerraformElement],
    ) -> builtins.str:
        '''(experimental) Returns the naming scheme used to allocate logical IDs.

        By default, uses
        the ``HashedAddressingScheme`` but this method can be overridden to customize
        this behavior.

        :param tf_element: The element for which the logical ID is allocated.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__81995ed9993d1687d068c687071f0a65f709bafa8be532e324bce983c6cd3aba)
            check_type(argname="argument tf_element", value=tf_element, expected_type=type_hints["tf_element"])
        return typing.cast(builtins.str, jsii.invoke(self, "allocateLogicalId", [tf_element]))

    @jsii.member(jsii_name="allProviders")
    def all_providers(self) -> typing.List[TerraformProvider]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[TerraformProvider], jsii.invoke(self, "allProviders", []))

    @jsii.member(jsii_name="dependsOn")
    def depends_on(self, stack: "TerraformStack") -> builtins.bool:
        '''
        :param stack: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__848536e95b42fb073abc5d703b9666de6e8d9f62ae006dc3ab9ff64e24c49c65)
            check_type(argname="argument stack", value=stack, expected_type=type_hints["stack"])
        return typing.cast(builtins.bool, jsii.invoke(self, "dependsOn", [stack]))

    @jsii.member(jsii_name="ensureBackendExists")
    def ensure_backend_exists(self) -> "TerraformBackend":
        '''
        :stability: experimental
        '''
        return typing.cast("TerraformBackend", jsii.invoke(self, "ensureBackendExists", []))

    @jsii.member(jsii_name="getLogicalId")
    def get_logical_id(
        self,
        tf_element: typing.Union[_constructs_77d1e7e8.Node, TerraformElement],
    ) -> builtins.str:
        '''
        :param tf_element: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ac63b7486cb2a705bf90134092b22480b1c01fd33ecc2582062574ccc0dd31fe)
            check_type(argname="argument tf_element", value=tf_element, expected_type=type_hints["tf_element"])
        return typing.cast(builtins.str, jsii.invoke(self, "getLogicalId", [tf_element]))

    @jsii.member(jsii_name="hasResourceMove")
    def has_resource_move(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.invoke(self, "hasResourceMove", []))

    @jsii.member(jsii_name="prepareStack")
    def prepare_stack(self) -> None:
        '''
        :stability: experimental
        '''
        return typing.cast(None, jsii.invoke(self, "prepareStack", []))

    @jsii.member(jsii_name="registerIncomingCrossStackReference")
    def register_incoming_cross_stack_reference(
        self,
        from_stack: "TerraformStack",
    ) -> TerraformRemoteState:
        '''
        :param from_stack: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f59d08fbe4359d82edaa4e1817aa13d68a8db6be88eebd9276ba69e7b9d38821)
            check_type(argname="argument from_stack", value=from_stack, expected_type=type_hints["from_stack"])
        return typing.cast(TerraformRemoteState, jsii.invoke(self, "registerIncomingCrossStackReference", [from_stack]))

    @jsii.member(jsii_name="registerOutgoingCrossStackReference")
    def register_outgoing_cross_stack_reference(
        self,
        identifier: builtins.str,
    ) -> TerraformOutput:
        '''
        :param identifier: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7c1889762df571429d5fed6627357da11abb5caf08489f645c94d440c0b97c4b)
            check_type(argname="argument identifier", value=identifier, expected_type=type_hints["identifier"])
        return typing.cast(TerraformOutput, jsii.invoke(self, "registerOutgoingCrossStackReference", [identifier]))

    @jsii.member(jsii_name="runAllValidations")
    def run_all_validations(self) -> None:
        '''(experimental) Run all validations on the stack.

        :stability: experimental
        '''
        return typing.cast(None, jsii.invoke(self, "runAllValidations", []))

    @jsii.member(jsii_name="toHclTerraform")
    def to_hcl_terraform(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "toHclTerraform", []))

    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toTerraform", []))

    @builtins.property
    @jsii.member(jsii_name="dependencies")
    def dependencies(self) -> typing.List["TerraformStack"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List["TerraformStack"], jsii.get(self, "dependencies"))

    @dependencies.setter
    def dependencies(self, value: typing.List["TerraformStack"]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e6040423e55b90bfc10e20a794a96303d0333f383aed4eada61c48bc462434e1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "dependencies", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="moveTargets")
    def move_targets(self) -> TerraformResourceTargets:
        '''
        :stability: experimental
        '''
        return typing.cast(TerraformResourceTargets, jsii.get(self, "moveTargets"))

    @move_targets.setter
    def move_targets(self, value: TerraformResourceTargets) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6fcf5e2a29bc4e9793f946f6b2e7c98a70363230e09c2cad0a7c652c011975fa)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "moveTargets", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="synthesizer")
    def synthesizer(self) -> IStackSynthesizer:
        '''
        :stability: experimental
        '''
        return typing.cast(IStackSynthesizer, jsii.get(self, "synthesizer"))

    @synthesizer.setter
    def synthesizer(self, value: IStackSynthesizer) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e1b3d9ed938408962e059234fbde4d2cd91f5a2105c00e3d3105e6a41d506776)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "synthesizer", value) # pyright: ignore[reportArgumentType]


@jsii.data_type(
    jsii_type="cdktn.TerraformStackMetadata",
    jsii_struct_bases=[],
    name_mapping={
        "backend": "backend",
        "stack_name": "stackName",
        "version": "version",
        "cloud": "cloud",
    },
)
class TerraformStackMetadata:
    def __init__(
        self,
        *,
        backend: builtins.str,
        stack_name: builtins.str,
        version: builtins.str,
        cloud: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param backend: 
        :param stack_name: 
        :param version: 
        :param cloud: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2c9b596787474264ad405763481e614acbecfbecd7882d4bb239efc0bb60c2f3)
            check_type(argname="argument backend", value=backend, expected_type=type_hints["backend"])
            check_type(argname="argument stack_name", value=stack_name, expected_type=type_hints["stack_name"])
            check_type(argname="argument version", value=version, expected_type=type_hints["version"])
            check_type(argname="argument cloud", value=cloud, expected_type=type_hints["cloud"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "backend": backend,
            "stack_name": stack_name,
            "version": version,
        }
        if cloud is not None:
            self._values["cloud"] = cloud

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

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

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

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


@jsii.implements(ITerraformAddressable)
class TerraformVariable(
    TerraformElement,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.TerraformVariable",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        default: typing.Any = None,
        description: typing.Optional[builtins.str] = None,
        nullable: typing.Optional[builtins.bool] = None,
        sensitive: typing.Optional[builtins.bool] = None,
        type: typing.Optional[builtins.str] = None,
        validation: typing.Optional[typing.Sequence[typing.Union["TerraformVariableValidationConfig", typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param default: 
        :param description: 
        :param nullable: 
        :param sensitive: 
        :param type: (experimental) The type argument in a variable block allows you to restrict the type of value that will be accepted as the value for a variable. If no type constraint is set then a value of any type is accepted. While type constraints are optional, we recommend specifying them; they serve as easy reminders for users of the module, and allow Terraform to return a helpful error message if the wrong type is used. Type constraints are created from a mixture of type keywords and type constructors. The supported type keywords are: - string - number - bool The type constructors allow you to specify complex types such as collections: - list(<TYPE>) - set(<TYPE>) - map(<TYPE>) - object({<ATTR NAME> = <TYPE>, ... }) - tuple([<TYPE>, ...]) The keyword any may be used to indicate that any type is acceptable. For more information on the meaning and behavior of these different types, as well as detailed information about automatic conversion of complex types, refer to {@link https://developer.hashicorp.com/terraform/language/expressions/type-constraints Type Constraints}. If both the type and default arguments are specified, the given default value must be convertible to the specified type.
        :param validation: (experimental) Specify arbitrary custom validation rules for a particular variable using a validation block nested within the corresponding variable block.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a969035b8f865ea849733f7d75773ea4c66688586f214f1637b395adbf88c223)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = TerraformVariableConfig(
            default=default,
            description=description,
            nullable=nullable,
            sensitive=sensitive,
            type=type,
            validation=validation,
        )

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

    @jsii.member(jsii_name="addValidation")
    def add_validation(
        self,
        *,
        condition: typing.Any,
        error_message: builtins.str,
    ) -> None:
        '''
        :param condition: (experimental) This is a boolean expression that should return true if the intended assumption or guarantee is fulfilled or false if it does not.
        :param error_message: (experimental) This contains the text that Terraform will include as part of error messages when it detects an unmet condition.

        :stability: experimental
        '''
        validation = TerraformVariableValidationConfig(
            condition=condition, error_message=error_message
        )

        return typing.cast(None, jsii.invoke(self, "addValidation", [validation]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))

    @jsii.member(jsii_name="toHclTerraform")
    def to_hcl_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toHclTerraform", []))

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''(experimental) Returns a string representation of this construct.

        :return: a string token referencing the value of this variable

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toTerraform", []))

    @builtins.property
    @jsii.member(jsii_name="booleanValue")
    def boolean_value(self) -> IResolvable:
        '''
        :stability: experimental
        '''
        return typing.cast(IResolvable, jsii.get(self, "booleanValue"))

    @builtins.property
    @jsii.member(jsii_name="listValue")
    def list_value(self) -> typing.List[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "listValue"))

    @builtins.property
    @jsii.member(jsii_name="numberValue")
    def number_value(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        return typing.cast(jsii.Number, jsii.get(self, "numberValue"))

    @builtins.property
    @jsii.member(jsii_name="stringValue")
    def string_value(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "stringValue"))

    @builtins.property
    @jsii.member(jsii_name="value")
    def value(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.get(self, "value"))

    @builtins.property
    @jsii.member(jsii_name="default")
    def default(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.get(self, "default"))

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

    @builtins.property
    @jsii.member(jsii_name="nullable")
    def nullable(self) -> typing.Optional[builtins.bool]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "nullable"))

    @builtins.property
    @jsii.member(jsii_name="sensitive")
    def sensitive(self) -> typing.Optional[builtins.bool]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "sensitive"))

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

    @builtins.property
    @jsii.member(jsii_name="validation")
    def validation(
        self,
    ) -> typing.Optional[typing.List["TerraformVariableValidationConfig"]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.List["TerraformVariableValidationConfig"]], jsii.get(self, "validation"))


@jsii.data_type(
    jsii_type="cdktn.TerraformVariableConfig",
    jsii_struct_bases=[],
    name_mapping={
        "default": "default",
        "description": "description",
        "nullable": "nullable",
        "sensitive": "sensitive",
        "type": "type",
        "validation": "validation",
    },
)
class TerraformVariableConfig:
    def __init__(
        self,
        *,
        default: typing.Any = None,
        description: typing.Optional[builtins.str] = None,
        nullable: typing.Optional[builtins.bool] = None,
        sensitive: typing.Optional[builtins.bool] = None,
        type: typing.Optional[builtins.str] = None,
        validation: typing.Optional[typing.Sequence[typing.Union["TerraformVariableValidationConfig", typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param default: 
        :param description: 
        :param nullable: 
        :param sensitive: 
        :param type: (experimental) The type argument in a variable block allows you to restrict the type of value that will be accepted as the value for a variable. If no type constraint is set then a value of any type is accepted. While type constraints are optional, we recommend specifying them; they serve as easy reminders for users of the module, and allow Terraform to return a helpful error message if the wrong type is used. Type constraints are created from a mixture of type keywords and type constructors. The supported type keywords are: - string - number - bool The type constructors allow you to specify complex types such as collections: - list(<TYPE>) - set(<TYPE>) - map(<TYPE>) - object({<ATTR NAME> = <TYPE>, ... }) - tuple([<TYPE>, ...]) The keyword any may be used to indicate that any type is acceptable. For more information on the meaning and behavior of these different types, as well as detailed information about automatic conversion of complex types, refer to {@link https://developer.hashicorp.com/terraform/language/expressions/type-constraints Type Constraints}. If both the type and default arguments are specified, the given default value must be convertible to the specified type.
        :param validation: (experimental) Specify arbitrary custom validation rules for a particular variable using a validation block nested within the corresponding variable block.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__41ac207b16d0a0a35cd187c0b2a67d73030a02ce461fe3819cc376ab138cbb6b)
            check_type(argname="argument default", value=default, expected_type=type_hints["default"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument nullable", value=nullable, expected_type=type_hints["nullable"])
            check_type(argname="argument sensitive", value=sensitive, expected_type=type_hints["sensitive"])
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument validation", value=validation, expected_type=type_hints["validation"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if default is not None:
            self._values["default"] = default
        if description is not None:
            self._values["description"] = description
        if nullable is not None:
            self._values["nullable"] = nullable
        if sensitive is not None:
            self._values["sensitive"] = sensitive
        if type is not None:
            self._values["type"] = type
        if validation is not None:
            self._values["validation"] = validation

    @builtins.property
    def default(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        result = self._values.get("default")
        return typing.cast(typing.Any, result)

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

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

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

    @builtins.property
    def type(self) -> typing.Optional[builtins.str]:
        '''(experimental) The type argument in a variable block allows you to restrict the type of value that will be accepted as the value for a variable.

        If no type constraint is set then a value of any type is accepted.

        While type constraints are optional, we recommend specifying them; they serve as easy reminders for users of the module, and allow Terraform to return a helpful error message if the wrong type is used.

        Type constraints are created from a mixture of type keywords and type constructors. The supported type keywords are:

        - string
        - number
        - bool

        The type constructors allow you to specify complex types such as collections:

        - list()
        - set()
        - map()
        - object({ = , ... })
        - tuple([, ...])

        The keyword any may be used to indicate that any type is acceptable. For more information on the meaning and behavior of these different types, as well as detailed information about automatic conversion of complex types, refer to {@link https://developer.hashicorp.com/terraform/language/expressions/type-constraints Type Constraints}.

        If both the type and default arguments are specified, the given default value must be convertible to the specified type.

        :stability: experimental
        '''
        result = self._values.get("type")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def validation(
        self,
    ) -> typing.Optional[typing.List["TerraformVariableValidationConfig"]]:
        '''(experimental) Specify arbitrary custom validation rules for a particular variable using a validation block nested within the corresponding variable block.

        :stability: experimental
        '''
        result = self._values.get("validation")
        return typing.cast(typing.Optional[typing.List["TerraformVariableValidationConfig"]], 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 "TerraformVariableConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.TerraformVariableValidationConfig",
    jsii_struct_bases=[TerraformCondition],
    name_mapping={"condition": "condition", "error_message": "errorMessage"},
)
class TerraformVariableValidationConfig(TerraformCondition):
    def __init__(self, *, condition: typing.Any, error_message: builtins.str) -> None:
        '''(experimental) Add one or more validation blocks within the variable block to specify custom conditions.

        :param condition: (experimental) This is a boolean expression that should return true if the intended assumption or guarantee is fulfilled or false if it does not.
        :param error_message: (experimental) This contains the text that Terraform will include as part of error messages when it detects an unmet condition.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__69cc7e6136cc8e43a13e39d449a8bcda996c6ca783f3cf58b34000601a6540b8)
            check_type(argname="argument condition", value=condition, expected_type=type_hints["condition"])
            check_type(argname="argument error_message", value=error_message, expected_type=type_hints["error_message"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "condition": condition,
            "error_message": error_message,
        }

    @builtins.property
    def condition(self) -> typing.Any:
        '''(experimental) This is a boolean expression that should return true if the intended assumption or guarantee is fulfilled or false if it does not.

        :stability: experimental
        '''
        result = self._values.get("condition")
        assert result is not None, "Required property 'condition' is missing"
        return typing.cast(typing.Any, result)

    @builtins.property
    def error_message(self) -> builtins.str:
        '''(experimental) This contains the text that Terraform will include as part of error messages when it detects an unmet condition.

        :stability: experimental
        '''
        result = self._values.get("error_message")
        assert result is not None, "Required property 'error_message' 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 "TerraformVariableValidationConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class Testing(metaclass=jsii.JSIIMeta, jsii_type="cdktn.Testing"):
    '''(experimental) Testing utilities for cdktf applications.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="app")
    @builtins.classmethod
    def app(
        cls,
        *,
        context: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        enable_future_flags: typing.Optional[builtins.bool] = None,
        fake_cdktf_json_path: typing.Optional[builtins.bool] = None,
        outdir: typing.Optional[builtins.str] = None,
        stack_traces: typing.Optional[builtins.bool] = None,
        stub_version: typing.Optional[builtins.bool] = None,
    ) -> App:
        '''(experimental) Returns an app for testing with the following properties: - Output directory is a temp dir.

        :param context: 
        :param enable_future_flags: 
        :param fake_cdktf_json_path: 
        :param outdir: 
        :param stack_traces: 
        :param stub_version: 

        :stability: experimental
        '''
        options = TestingAppConfig(
            context=context,
            enable_future_flags=enable_future_flags,
            fake_cdktf_json_path=fake_cdktf_json_path,
            outdir=outdir,
            stack_traces=stack_traces,
            stub_version=stub_version,
        )

        return typing.cast(App, jsii.sinvoke(cls, "app", [options]))

    @jsii.member(jsii_name="enableFutureFlags")
    @builtins.classmethod
    def enable_future_flags(cls, app: App) -> App:
        '''
        :param app: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d1763559f423b2c3bd4b7c7ed1e294651415a94e44e18c67a92f022d5818c51e)
            check_type(argname="argument app", value=app, expected_type=type_hints["app"])
        return typing.cast(App, jsii.sinvoke(cls, "enableFutureFlags", [app]))

    @jsii.member(jsii_name="fakeCdktfJsonPath")
    @builtins.classmethod
    def fake_cdktf_json_path(cls, app: App) -> App:
        '''
        :param app: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__58c7cb862b7200385eb19ec8f21081639d9fe92275abcdbf088702f8943ad738)
            check_type(argname="argument app", value=app, expected_type=type_hints["app"])
        return typing.cast(App, jsii.sinvoke(cls, "fakeCdktfJsonPath", [app]))

    @jsii.member(jsii_name="fullSynth")
    @builtins.classmethod
    def full_synth(cls, stack: TerraformStack) -> builtins.str:
        '''
        :param stack: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b60a0582b77b2ac1167b99b2194a2d80a96166bde945c5d8a09111a65286009d)
            check_type(argname="argument stack", value=stack, expected_type=type_hints["stack"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "fullSynth", [stack]))

    @jsii.member(jsii_name="renderConstructTree")
    @builtins.classmethod
    def render_construct_tree(
        cls,
        construct: _constructs_77d1e7e8.IConstruct,
    ) -> builtins.str:
        '''
        :param construct: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9a5842df674b32b03f781ab4d610dabecb7da43fac9bed4fc37cf58a2d70b7c7)
            check_type(argname="argument construct", value=construct, expected_type=type_hints["construct"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "renderConstructTree", [construct]))

    @jsii.member(jsii_name="setupJest")
    @builtins.classmethod
    def setup_jest(cls) -> None:
        '''
        :stability: experimental
        '''
        return typing.cast(None, jsii.sinvoke(cls, "setupJest", []))

    @jsii.member(jsii_name="stubVersion")
    @builtins.classmethod
    def stub_version(cls, app: App) -> App:
        '''
        :param app: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7d53a3670b7c5417376165f346ccd1ec40f4c623af4b83d37d5b6e2daa404f59)
            check_type(argname="argument app", value=app, expected_type=type_hints["app"])
        return typing.cast(App, jsii.sinvoke(cls, "stubVersion", [app]))

    @jsii.member(jsii_name="synth")
    @builtins.classmethod
    def synth(
        cls,
        stack: TerraformStack,
        run_validations: typing.Optional[builtins.bool] = None,
    ) -> builtins.str:
        '''(experimental) Returns the Terraform synthesized JSON.

        :param stack: -
        :param run_validations: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__708be873e1eb9488e6cde21497ff9177ad18dac95d9a03d09a4386260c3bdd17)
            check_type(argname="argument stack", value=stack, expected_type=type_hints["stack"])
            check_type(argname="argument run_validations", value=run_validations, expected_type=type_hints["run_validations"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "synth", [stack, run_validations]))

    @jsii.member(jsii_name="synthHcl")
    @builtins.classmethod
    def synth_hcl(
        cls,
        stack: TerraformStack,
        run_validations: typing.Optional[builtins.bool] = None,
        return_metadata: typing.Optional[builtins.bool] = None,
    ) -> typing.Any:
        '''(experimental) Returns the Terraform synthesized JSON.

        :param stack: -
        :param run_validations: -
        :param return_metadata: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__459afd0ccca40a57a9946156a4069393ce0bafe18ad13b4a02644b34b0a21bf8)
            check_type(argname="argument stack", value=stack, expected_type=type_hints["stack"])
            check_type(argname="argument run_validations", value=run_validations, expected_type=type_hints["run_validations"])
            check_type(argname="argument return_metadata", value=return_metadata, expected_type=type_hints["return_metadata"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "synthHcl", [stack, run_validations, return_metadata]))

    @jsii.member(jsii_name="synthScope")
    @builtins.classmethod
    def synth_scope(cls, fn: IScopeCallback) -> builtins.str:
        '''
        :param fn: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__08f677a487438755df8d5551ce7c3ac4eeb764b3d10fe566244aa5c70df74fe3)
            check_type(argname="argument fn", value=fn, expected_type=type_hints["fn"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "synthScope", [fn]))

    @jsii.member(jsii_name="toBeValidTerraform")
    @builtins.classmethod
    def to_be_valid_terraform(cls, received: builtins.str) -> builtins.bool:
        '''
        :param received: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__336b4e075f4b229ca2d10bb304a4e2ea87d2e2cea304f86f29bfbcd6ebaac56c)
            check_type(argname="argument received", value=received, expected_type=type_hints["received"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "toBeValidTerraform", [received]))

    @jsii.member(jsii_name="toHaveDataSource")
    @builtins.classmethod
    def to_have_data_source(
        cls,
        received: builtins.str,
        resource_type: builtins.str,
    ) -> builtins.bool:
        '''
        :param received: -
        :param resource_type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__104f104124c8997f80ff16a066d01dba38faa7959b9ca8fcab72b8f44f7d7277)
            check_type(argname="argument received", value=received, expected_type=type_hints["received"])
            check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "toHaveDataSource", [received, resource_type]))

    @jsii.member(jsii_name="toHaveDataSourceWithProperties")
    @builtins.classmethod
    def to_have_data_source_with_properties(
        cls,
        received: builtins.str,
        resource_type: builtins.str,
        properties: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    ) -> builtins.bool:
        '''
        :param received: -
        :param resource_type: -
        :param properties: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b89efe1c7a4317f3163281a3f15bb450efbe265aa8b65e9ef683f090af506a21)
            check_type(argname="argument received", value=received, expected_type=type_hints["received"])
            check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
            check_type(argname="argument properties", value=properties, expected_type=type_hints["properties"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "toHaveDataSourceWithProperties", [received, resource_type, properties]))

    @jsii.member(jsii_name="toHaveProvider")
    @builtins.classmethod
    def to_have_provider(
        cls,
        received: builtins.str,
        resource_type: builtins.str,
    ) -> builtins.bool:
        '''
        :param received: -
        :param resource_type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__62b143487665be5357f9ffe8a2858c0f6288baa1c9872c9c0b8089d27b14e8d2)
            check_type(argname="argument received", value=received, expected_type=type_hints["received"])
            check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "toHaveProvider", [received, resource_type]))

    @jsii.member(jsii_name="toHaveProviderWithProperties")
    @builtins.classmethod
    def to_have_provider_with_properties(
        cls,
        received: builtins.str,
        resource_type: builtins.str,
        properties: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    ) -> builtins.bool:
        '''
        :param received: -
        :param resource_type: -
        :param properties: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9b94c5f3242aa07baa0dfd8cd525104622027db6d0ad2248ca3a476c16f19bad)
            check_type(argname="argument received", value=received, expected_type=type_hints["received"])
            check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
            check_type(argname="argument properties", value=properties, expected_type=type_hints["properties"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "toHaveProviderWithProperties", [received, resource_type, properties]))

    @jsii.member(jsii_name="toHaveResource")
    @builtins.classmethod
    def to_have_resource(
        cls,
        received: builtins.str,
        resource_type: builtins.str,
    ) -> builtins.bool:
        '''
        :param received: -
        :param resource_type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__304edc769baf0e425a3207acd8cdc8481bfec595fb815a9cc1e2bcd59eae4f3e)
            check_type(argname="argument received", value=received, expected_type=type_hints["received"])
            check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "toHaveResource", [received, resource_type]))

    @jsii.member(jsii_name="toHaveResourceWithProperties")
    @builtins.classmethod
    def to_have_resource_with_properties(
        cls,
        received: builtins.str,
        resource_type: builtins.str,
        properties: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    ) -> builtins.bool:
        '''
        :param received: -
        :param resource_type: -
        :param properties: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eeed515a0a17633eac0cb32da5819e663ea932a4f2074089fbd70398dfc4e2fc)
            check_type(argname="argument received", value=received, expected_type=type_hints["received"])
            check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
            check_type(argname="argument properties", value=properties, expected_type=type_hints["properties"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "toHaveResourceWithProperties", [received, resource_type, properties]))


@jsii.data_type(
    jsii_type="cdktn.TestingAppConfig",
    jsii_struct_bases=[],
    name_mapping={
        "context": "context",
        "enable_future_flags": "enableFutureFlags",
        "fake_cdktf_json_path": "fakeCdktfJsonPath",
        "outdir": "outdir",
        "stack_traces": "stackTraces",
        "stub_version": "stubVersion",
    },
)
class TestingAppConfig:
    def __init__(
        self,
        *,
        context: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        enable_future_flags: typing.Optional[builtins.bool] = None,
        fake_cdktf_json_path: typing.Optional[builtins.bool] = None,
        outdir: typing.Optional[builtins.str] = None,
        stack_traces: typing.Optional[builtins.bool] = None,
        stub_version: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param context: 
        :param enable_future_flags: 
        :param fake_cdktf_json_path: 
        :param outdir: 
        :param stack_traces: 
        :param stub_version: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__54ebed42df621f5e0f84c586a54b6bb7006a38bba2c37cdfd5cb22165b743e22)
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
            check_type(argname="argument enable_future_flags", value=enable_future_flags, expected_type=type_hints["enable_future_flags"])
            check_type(argname="argument fake_cdktf_json_path", value=fake_cdktf_json_path, expected_type=type_hints["fake_cdktf_json_path"])
            check_type(argname="argument outdir", value=outdir, expected_type=type_hints["outdir"])
            check_type(argname="argument stack_traces", value=stack_traces, expected_type=type_hints["stack_traces"])
            check_type(argname="argument stub_version", value=stub_version, expected_type=type_hints["stub_version"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if context is not None:
            self._values["context"] = context
        if enable_future_flags is not None:
            self._values["enable_future_flags"] = enable_future_flags
        if fake_cdktf_json_path is not None:
            self._values["fake_cdktf_json_path"] = fake_cdktf_json_path
        if outdir is not None:
            self._values["outdir"] = outdir
        if stack_traces is not None:
            self._values["stack_traces"] = stack_traces
        if stub_version is not None:
            self._values["stub_version"] = stub_version

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

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

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

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

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

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


class Token(metaclass=jsii.JSIIMeta, jsii_type="cdktn.Token"):
    '''(experimental) Represents a special or lazily-evaluated value.

    Can be used to delay evaluation of a certain value in case, for example,
    that it requires some context or late-bound data. Can also be used to
    mark values that need special processing at document rendering time.

    Tokens can be embedded into strings while retaining their original
    semantics.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="asAny")
    @builtins.classmethod
    def as_any(cls, value: typing.Any) -> IResolvable:
        '''(experimental) Return a resolvable representation of the given value.

        :param value: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fc2cd80016e9f94ac59b50e582e35b08dbf29bb09b05b08b2003fe479db11ce0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        return typing.cast(IResolvable, jsii.sinvoke(cls, "asAny", [value]))

    @jsii.member(jsii_name="asAnyMap")
    @builtins.classmethod
    def as_any_map(
        cls,
        value: typing.Any,
        *,
        display_hint: typing.Optional[builtins.str] = None,
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''(experimental) Return a reversible map representation of this token.

        :param value: -
        :param display_hint: (experimental) A hint for the Token's purpose when stringifying it. Default: - no display hint

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d35a6be6d86454a16b83a0001bfe337c7fde1dbbc211a75d3466402e544aca2d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        options = EncodingOptions(display_hint=display_hint)

        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.sinvoke(cls, "asAnyMap", [value, options]))

    @jsii.member(jsii_name="asBooleanMap")
    @builtins.classmethod
    def as_boolean_map(
        cls,
        value: typing.Any,
        *,
        display_hint: typing.Optional[builtins.str] = None,
    ) -> typing.Mapping[builtins.str, builtins.bool]:
        '''(experimental) Return a reversible map representation of this token.

        :param value: -
        :param display_hint: (experimental) A hint for the Token's purpose when stringifying it. Default: - no display hint

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__55ed021c804ca095d1c1c528ace6a7f229d32f175807f73c4035d8fe16b4648d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        options = EncodingOptions(display_hint=display_hint)

        return typing.cast(typing.Mapping[builtins.str, builtins.bool], jsii.sinvoke(cls, "asBooleanMap", [value, options]))

    @jsii.member(jsii_name="asList")
    @builtins.classmethod
    def as_list(
        cls,
        value: typing.Any,
        *,
        display_hint: typing.Optional[builtins.str] = None,
    ) -> typing.List[builtins.str]:
        '''(experimental) Return a reversible list representation of this token.

        :param value: -
        :param display_hint: (experimental) A hint for the Token's purpose when stringifying it. Default: - no display hint

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6989bc34c30ed4684b7ee53f7819ad02efed73c93978358183d2ee51d7889906)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        options = EncodingOptions(display_hint=display_hint)

        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "asList", [value, options]))

    @jsii.member(jsii_name="asMap")
    @builtins.classmethod
    def as_map(
        cls,
        value: typing.Any,
        map_value: typing.Any,
        *,
        display_hint: typing.Optional[builtins.str] = None,
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''(experimental) Return a reversible map representation of this token.

        :param value: -
        :param map_value: -
        :param display_hint: (experimental) A hint for the Token's purpose when stringifying it. Default: - no display hint

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ca2e0529b5c3ad3ed1d9caac6bfd77980cd0091a5a1d4b6fef86db6f419a956f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
            check_type(argname="argument map_value", value=map_value, expected_type=type_hints["map_value"])
        options = EncodingOptions(display_hint=display_hint)

        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.sinvoke(cls, "asMap", [value, map_value, options]))

    @jsii.member(jsii_name="asNumber")
    @builtins.classmethod
    def as_number(cls, value: typing.Any) -> jsii.Number:
        '''(experimental) Return a reversible number representation of this token.

        :param value: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c4399f43bd8dded7c40f7ad23599b180813d8eb290159f01aa53f5100c5c8db4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        return typing.cast(jsii.Number, jsii.sinvoke(cls, "asNumber", [value]))

    @jsii.member(jsii_name="asNumberList")
    @builtins.classmethod
    def as_number_list(cls, value: typing.Any) -> typing.List[jsii.Number]:
        '''(experimental) Return a reversible list representation of this token.

        :param value: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__335b6bfc8a5f027b594d82b93979ae32b68435b6ce301cab3695cb70cb81e69b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        return typing.cast(typing.List[jsii.Number], jsii.sinvoke(cls, "asNumberList", [value]))

    @jsii.member(jsii_name="asNumberMap")
    @builtins.classmethod
    def as_number_map(
        cls,
        value: typing.Any,
        *,
        display_hint: typing.Optional[builtins.str] = None,
    ) -> typing.Mapping[builtins.str, jsii.Number]:
        '''(experimental) Return a reversible map representation of this token.

        :param value: -
        :param display_hint: (experimental) A hint for the Token's purpose when stringifying it. Default: - no display hint

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c537112371292f9fcba99f73281f0c16ab952fa784453d4d7b9a7cb7ee6b3803)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        options = EncodingOptions(display_hint=display_hint)

        return typing.cast(typing.Mapping[builtins.str, jsii.Number], jsii.sinvoke(cls, "asNumberMap", [value, options]))

    @jsii.member(jsii_name="asString")
    @builtins.classmethod
    def as_string(
        cls,
        value: typing.Any,
        *,
        display_hint: typing.Optional[builtins.str] = None,
    ) -> builtins.str:
        '''(experimental) Return a reversible string representation of this token.

        If the Token is initialized with a literal, the stringified value of the
        literal is returned. Otherwise, a special quoted string representation
        of the Token is returned that can be embedded into other strings.

        Strings with quoted Tokens in them can be restored back into
        complex values with the Tokens restored by calling ``resolve()``
        on the string.

        :param value: -
        :param display_hint: (experimental) A hint for the Token's purpose when stringifying it. Default: - no display hint

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__42335670d8fc9bd10abb7ac0b2791311b96f5e719ebb23d93745f1415f45ef28)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        options = EncodingOptions(display_hint=display_hint)

        return typing.cast(builtins.str, jsii.sinvoke(cls, "asString", [value, options]))

    @jsii.member(jsii_name="asStringMap")
    @builtins.classmethod
    def as_string_map(
        cls,
        value: typing.Any,
        *,
        display_hint: typing.Optional[builtins.str] = None,
    ) -> typing.Mapping[builtins.str, builtins.str]:
        '''(experimental) Return a reversible map representation of this token.

        :param value: -
        :param display_hint: (experimental) A hint for the Token's purpose when stringifying it. Default: - no display hint

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ec70f02947e6d29970d3cfe6c973938b6f7c30a6afac843edbe6875242568821)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        options = EncodingOptions(display_hint=display_hint)

        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.sinvoke(cls, "asStringMap", [value, options]))

    @jsii.member(jsii_name="isUnresolved")
    @builtins.classmethod
    def is_unresolved(cls, obj: typing.Any) -> builtins.bool:
        '''(experimental) Returns true if obj represents an unresolved value.

        One of these must be true:

        - ``obj`` is an IResolvable
        - ``obj`` is a string containing at least one encoded ``IResolvable``
        - ``obj`` is either an encoded number or list

        This does NOT recurse into lists or objects to see if they
        containing resolvables.

        :param obj: The object to test.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cede694fed113a58a15be36452d545bb2d5e400f448470fe12930a3309426c1f)
            check_type(argname="argument obj", value=obj, expected_type=type_hints["obj"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "isUnresolved", [obj]))

    @jsii.member(jsii_name="nullValue")
    @builtins.classmethod
    def null_value(cls) -> IResolvable:
        '''(experimental) Return a Token containing a ``null`` value.

        Note: This is different than ``undefined``, ``nil``, ``None`` or similar
        as it will end up in the Terraform config and can be used to explicitly
        not set an attribute (which is sometimes required by Terraform providers)

        :return: a Token resolving to ``null`` as understood by Terraform

        :stability: experimental
        '''
        return typing.cast(IResolvable, jsii.sinvoke(cls, "nullValue", []))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ANY_MAP_TOKEN_VALUE")
    def ANY_MAP_TOKEN_VALUE(cls) -> builtins.str:
        '''(experimental) Any map token representation.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "ANY_MAP_TOKEN_VALUE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="NUMBER_MAP_TOKEN_VALUE")
    def NUMBER_MAP_TOKEN_VALUE(cls) -> jsii.Number:
        '''(experimental) Number Map token value representation.

        :stability: experimental
        '''
        return typing.cast(jsii.Number, jsii.sget(cls, "NUMBER_MAP_TOKEN_VALUE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="STRING_MAP_TOKEN_VALUE")
    def STRING_MAP_TOKEN_VALUE(cls) -> builtins.str:
        '''(experimental) String Map token value representation.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "STRING_MAP_TOKEN_VALUE"))


class Tokenization(metaclass=jsii.JSIIMeta, jsii_type="cdktn.Tokenization"):
    '''(experimental) Less oft-needed functions to manipulate Tokens.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="isResolvable")
    @builtins.classmethod
    def is_resolvable(cls, obj: typing.Any) -> builtins.bool:
        '''(experimental) Return whether the given object is an IResolvable object.

        This is different from Token.isUnresolved() which will also check for
        encoded Tokens, whereas this method will only do a type check on the given
        object.

        :param obj: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2b1e3dd401bbec2c668fc76635fe5144d07edfe88c6f582e4003cf3c214f4167)
            check_type(argname="argument obj", value=obj, expected_type=type_hints["obj"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "isResolvable", [obj]))

    @jsii.member(jsii_name="resolve")
    @builtins.classmethod
    def resolve(
        cls,
        obj: typing.Any,
        *,
        resolver: ITokenResolver,
        scope: _constructs_77d1e7e8.IConstruct,
        preparing: typing.Optional[builtins.bool] = None,
    ) -> typing.Any:
        '''(experimental) Resolves an object by evaluating all tokens and removing any undefined or empty objects or arrays.

        Values can only be primitives, arrays or tokens. Other objects (i.e. with methods) will be rejected.

        :param obj: The object to resolve.
        :param resolver: (experimental) The resolver to apply to any resolvable tokens found.
        :param scope: (experimental) The scope from which resolution is performed.
        :param preparing: (experimental) Whether the resolution is being executed during the prepare phase or not. Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b2e20c09b2c2c3be7b7941486816bd2168fe3cc67c66761ee9e115c8ba72b837)
            check_type(argname="argument obj", value=obj, expected_type=type_hints["obj"])
        options = ResolveOptions(resolver=resolver, scope=scope, preparing=preparing)

        return typing.cast(typing.Any, jsii.sinvoke(cls, "resolve", [obj, options]))

    @jsii.member(jsii_name="reverse")
    @builtins.classmethod
    def reverse(cls, x: typing.Any) -> typing.List[IResolvable]:
        '''(experimental) Reverse any value into Resolvables, if possible.

        :param x: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__36585866150c5a1486cd4a1a88557fd79f71301379b144933150fc14e7898c43)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(typing.List[IResolvable], jsii.sinvoke(cls, "reverse", [x]))

    @jsii.member(jsii_name="reverseList")
    @builtins.classmethod
    def reverse_list(
        cls,
        l: typing.Sequence[builtins.str],
    ) -> typing.Optional[IResolvable]:
        '''(experimental) Un-encode a Tokenized value from a list.

        :param l: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8a90fcdf582806b8ddadfa6c0703cf9b79e6c11715546d4e90f0f41dfec0fadc)
            check_type(argname="argument l", value=l, expected_type=type_hints["l"])
        return typing.cast(typing.Optional[IResolvable], jsii.sinvoke(cls, "reverseList", [l]))

    @jsii.member(jsii_name="reverseMap")
    @builtins.classmethod
    def reverse_map(
        cls,
        m: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Optional[IResolvable]:
        '''(experimental) Un-encode a Tokenized value from a map.

        :param m: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__763100f1b78b113cb90c6679794ce40174f8466a3abe47320c5cba273f62c186)
            check_type(argname="argument m", value=m, expected_type=type_hints["m"])
        return typing.cast(typing.Optional[IResolvable], jsii.sinvoke(cls, "reverseMap", [m]))

    @jsii.member(jsii_name="reverseNumber")
    @builtins.classmethod
    def reverse_number(cls, n: jsii.Number) -> typing.Optional[IResolvable]:
        '''(experimental) Un-encode a Tokenized value from a number.

        :param n: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__915bc6dffd808180690af80a1bfcc3d701f2659b4d386d6dfe3a87082bc581bb)
            check_type(argname="argument n", value=n, expected_type=type_hints["n"])
        return typing.cast(typing.Optional[IResolvable], jsii.sinvoke(cls, "reverseNumber", [n]))

    @jsii.member(jsii_name="reverseNumberList")
    @builtins.classmethod
    def reverse_number_list(
        cls,
        l: typing.Sequence[jsii.Number],
    ) -> typing.Optional[IResolvable]:
        '''(experimental) Un-encode a Tokenized value from a list.

        :param l: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6a087f957e4b3b11006552646753964911a588b5df4cdc8ac52e0dfae9c01526)
            check_type(argname="argument l", value=l, expected_type=type_hints["l"])
        return typing.cast(typing.Optional[IResolvable], jsii.sinvoke(cls, "reverseNumberList", [l]))

    @jsii.member(jsii_name="reverseString")
    @builtins.classmethod
    def reverse_string(cls, s: builtins.str) -> "TokenizedStringFragments":
        '''(experimental) Un-encode a string potentially containing encoded tokens.

        :param s: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__50ad8a3aed96e8c9e263262e3602136d6207fe84c51dd837dde4b58535d49974)
            check_type(argname="argument s", value=s, expected_type=type_hints["s"])
        return typing.cast("TokenizedStringFragments", jsii.sinvoke(cls, "reverseString", [s]))

    @jsii.member(jsii_name="stringifyNumber")
    @builtins.classmethod
    def stringify_number(cls, x: jsii.Number) -> builtins.str:
        '''(experimental) Stringify a number directly or lazily if it's a Token.

        If it is an object (i.e., { Ref: 'SomeLogicalId' }), return it as-is.

        :param x: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__302830f1188af486903646901f86420db21828660a2fb8cc252422c599146208)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "stringifyNumber", [x]))


class TokenizedStringFragments(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.TokenizedStringFragments",
):
    '''(experimental) Fragments of a concatenated string containing stringified Tokens.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="addEscape")
    def add_escape(self, kind: builtins.str) -> None:
        '''
        :param kind: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7c755437d3f45016ac389f5813b2404686a9c05f2b6a792b15d04416fd643295)
            check_type(argname="argument kind", value=kind, expected_type=type_hints["kind"])
        return typing.cast(None, jsii.invoke(self, "addEscape", [kind]))

    @jsii.member(jsii_name="addIntrinsic")
    def add_intrinsic(self, value: typing.Any) -> None:
        '''(experimental) Adds an intrinsic fragment.

        :param value: the intrinsic value to add.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cf1499b4dc541e9015aacaf427ff0826703cd9bd43e4c492bfec7685e406c695)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        return typing.cast(None, jsii.invoke(self, "addIntrinsic", [value]))

    @jsii.member(jsii_name="addLiteral")
    def add_literal(self, lit: typing.Any) -> None:
        '''(experimental) Adds a literal fragment.

        :param lit: the literal to add.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__11914f82a68bc3034468f060be634da21edccea26889ad9601127542cf13b343)
            check_type(argname="argument lit", value=lit, expected_type=type_hints["lit"])
        return typing.cast(None, jsii.invoke(self, "addLiteral", [lit]))

    @jsii.member(jsii_name="addToken")
    def add_token(self, token: IResolvable) -> None:
        '''(experimental) Adds a token fragment.

        :param token: the token to add.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c0558b50fadb857c241e3458711be70196edf14e603cd97450f5638583171176)
            check_type(argname="argument token", value=token, expected_type=type_hints["token"])
        return typing.cast(None, jsii.invoke(self, "addToken", [token]))

    @jsii.member(jsii_name="concat")
    def concat(self, other: "TokenizedStringFragments") -> None:
        '''
        :param other: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9a1302156b456acf39397723979f061e21ef955011da56edf3d52b8f1926f85e)
            check_type(argname="argument other", value=other, expected_type=type_hints["other"])
        return typing.cast(None, jsii.invoke(self, "concat", [other]))

    @jsii.member(jsii_name="join")
    def join(self, concat: IFragmentConcatenator) -> typing.Any:
        '''(experimental) Combine the string fragments using the given joiner.

        If there are any

        :param concat: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e4560ceb1b64de42c523e63fb0b39ff1c5a80f45f5ddbc45fedfd7b443e6b758)
            check_type(argname="argument concat", value=concat, expected_type=type_hints["concat"])
        return typing.cast(typing.Any, jsii.invoke(self, "join", [concat]))

    @jsii.member(jsii_name="mapTokens")
    def map_tokens(self, context: IResolveContext) -> "TokenizedStringFragments":
        '''(experimental) Apply a transformation function to all tokens in the string.

        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c6a2a9092fc7b0d69e682541e57008cf468ff527ec2b5afddeec67409d8056c6)
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast("TokenizedStringFragments", jsii.invoke(self, "mapTokens", [context]))

    @builtins.property
    @jsii.member(jsii_name="escapes")
    def escapes(self) -> typing.List[IResolvable]:
        '''(experimental) Return all escape fragments from this string.

        :stability: experimental
        '''
        return typing.cast(typing.List[IResolvable], jsii.get(self, "escapes"))

    @builtins.property
    @jsii.member(jsii_name="firstValue")
    def first_value(self) -> typing.Any:
        '''(experimental) Returns the first value.

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.get(self, "firstValue"))

    @builtins.property
    @jsii.member(jsii_name="intrinsic")
    def intrinsic(self) -> typing.List[IResolvable]:
        '''(experimental) Return all intrinsic fragments from this string.

        :stability: experimental
        '''
        return typing.cast(typing.List[IResolvable], jsii.get(self, "intrinsic"))

    @builtins.property
    @jsii.member(jsii_name="length")
    def length(self) -> jsii.Number:
        '''(experimental) Returns the number of fragments.

        :stability: experimental
        '''
        return typing.cast(jsii.Number, jsii.get(self, "length"))

    @builtins.property
    @jsii.member(jsii_name="literals")
    def literals(self) -> typing.List[IResolvable]:
        '''(experimental) Return all literals from this string.

        :stability: experimental
        '''
        return typing.cast(typing.List[IResolvable], jsii.get(self, "literals"))

    @builtins.property
    @jsii.member(jsii_name="tokens")
    def tokens(self) -> typing.List[IResolvable]:
        '''(experimental) Return all Tokens from this string.

        :stability: experimental
        '''
        return typing.cast(typing.List[IResolvable], jsii.get(self, "tokens"))

    @builtins.property
    @jsii.member(jsii_name="firstToken")
    def first_token(self) -> typing.Optional[IResolvable]:
        '''(experimental) Returns the first token.

        :stability: experimental
        '''
        return typing.cast(typing.Optional[IResolvable], jsii.get(self, "firstToken"))


class VariableType(metaclass=jsii.JSIIAbstractClass, jsii_type="cdktn.VariableType"):
    '''
    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="list")
    @builtins.classmethod
    def list(cls, type: builtins.str) -> builtins.str:
        '''
        :param type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__99166e7f5fb92595f01f21f45a7dd36e29bd69b05937cdc5582f9c88e62a7d36)
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "list", [type]))

    @jsii.member(jsii_name="map")
    @builtins.classmethod
    def map(cls, type: builtins.str) -> builtins.str:
        '''
        :param type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8d7120ba82034be5b853e5a51f69265bd8fb74707990a998558251be7fb1555d)
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "map", [type]))

    @jsii.member(jsii_name="object")
    @builtins.classmethod
    def object(
        cls,
        attributes: typing.Mapping[builtins.str, builtins.str],
    ) -> builtins.str:
        '''
        :param attributes: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__87149a89b8cf58365e8930eda5f43c2214b64439aa47fde55ba5373f61b7ad21)
            check_type(argname="argument attributes", value=attributes, expected_type=type_hints["attributes"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "object", [attributes]))

    @jsii.member(jsii_name="set")
    @builtins.classmethod
    def set(cls, type: builtins.str) -> builtins.str:
        '''
        :param type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a98af255ebba41602ad72de9d0ad46ef0c089b5997acf58c7c0d71a258156128)
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "set", [type]))

    @jsii.member(jsii_name="tuple")
    @builtins.classmethod
    def tuple(cls, *elements: builtins.str) -> builtins.str:
        '''
        :param elements: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5793ed0887c7db4221c0fa84e8326927e6094f2a5e821220c145a1ab020f2b3f)
            check_type(argname="argument elements", value=elements, expected_type=typing.Tuple[type_hints["elements"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(builtins.str, jsii.sinvoke(cls, "tuple", [*elements]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ANY")
    def ANY(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "ANY"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="BOOL")
    def BOOL(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "BOOL"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="LIST")
    def LIST(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "LIST"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="LIST_BOOL")
    def LIST_BOOL(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "LIST_BOOL"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="LIST_NUMBER")
    def LIST_NUMBER(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "LIST_NUMBER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="LIST_STRING")
    def LIST_STRING(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "LIST_STRING"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MAP")
    def MAP(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "MAP"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MAP_BOOL")
    def MAP_BOOL(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "MAP_BOOL"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MAP_NUMBER")
    def MAP_NUMBER(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "MAP_NUMBER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MAP_STRING")
    def MAP_STRING(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "MAP_STRING"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="NUMBER")
    def NUMBER(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "NUMBER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SET")
    def SET(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "SET"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SET_BOOL")
    def SET_BOOL(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "SET_BOOL"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SET_NUMBER")
    def SET_NUMBER(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "SET_NUMBER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SET_STRING")
    def SET_STRING(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "SET_STRING"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="STRING")
    def STRING(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "STRING"))


class _VariableTypeProxy(VariableType):
    pass

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


@jsii.data_type(
    jsii_type="cdktn.WinrmProvisionerConnection",
    jsii_struct_bases=[],
    name_mapping={
        "host": "host",
        "type": "type",
        "cacert": "cacert",
        "https": "https",
        "insecure": "insecure",
        "password": "password",
        "port": "port",
        "script_path": "scriptPath",
        "timeout": "timeout",
        "use_ntlm": "useNtlm",
        "user": "user",
    },
)
class WinrmProvisionerConnection:
    def __init__(
        self,
        *,
        host: builtins.str,
        type: builtins.str,
        cacert: typing.Optional[builtins.str] = None,
        https: typing.Optional[builtins.bool] = None,
        insecure: typing.Optional[builtins.bool] = None,
        password: typing.Optional[builtins.str] = None,
        port: typing.Optional[jsii.Number] = None,
        script_path: typing.Optional[builtins.str] = None,
        timeout: typing.Optional[builtins.str] = None,
        use_ntlm: typing.Optional[builtins.bool] = None,
        user: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Most provisioners require access to the remote resource via SSH or WinRM and expect a nested connection block with details about how to connect.

        See {@link https://developer.hashicorp.com/terraform/language/resources/provisioners/connection connection}

        :param host: (experimental) The address of the resource to connect to.
        :param type: (experimental) The connection type. Valid values are "ssh" and "winrm". Provisioners typically assume that the remote system runs Microsoft Windows when using WinRM. Behaviors based on the SSH target_platform will force Windows-specific behavior for WinRM, unless otherwise specified.
        :param cacert: (experimental) The CA certificate to validate against.
        :param https: (experimental) Set to true to connect using HTTPS instead of HTTP.
        :param insecure: (experimental) Set to true to skip validating the HTTPS certificate chain.
        :param password: (experimental) The password to use for the connection.
        :param port: (experimental) The port to connect to. Default: 22
        :param script_path: (experimental) The path used to copy scripts meant for remote execution. Refer to {@link https://developer.hashicorp.com/terraform/language/resources/provisioners/connection#how-provisioners-execute-remote-scripts How Provisioners Execute Remote Scripts below for more details}
        :param timeout: (experimental) The timeout to wait for the connection to become available. Should be provided as a string (e.g., "30s" or "5m".) Default: 5m
        :param use_ntlm: (experimental) Set to true to use NTLM authentication rather than default (basic authentication), removing the requirement for basic authentication to be enabled within the target guest. Refer to Authentication for Remote Connections in the Windows App Development documentation for more details.
        :param user: (experimental) The user to use for the connection. Default: root

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4d651502c2fffe806b706fb54bd0004a60512941359af52ff80d63b3fa46da95)
            check_type(argname="argument host", value=host, expected_type=type_hints["host"])
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument cacert", value=cacert, expected_type=type_hints["cacert"])
            check_type(argname="argument https", value=https, expected_type=type_hints["https"])
            check_type(argname="argument insecure", value=insecure, expected_type=type_hints["insecure"])
            check_type(argname="argument password", value=password, expected_type=type_hints["password"])
            check_type(argname="argument port", value=port, expected_type=type_hints["port"])
            check_type(argname="argument script_path", value=script_path, expected_type=type_hints["script_path"])
            check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
            check_type(argname="argument use_ntlm", value=use_ntlm, expected_type=type_hints["use_ntlm"])
            check_type(argname="argument user", value=user, expected_type=type_hints["user"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "host": host,
            "type": type,
        }
        if cacert is not None:
            self._values["cacert"] = cacert
        if https is not None:
            self._values["https"] = https
        if insecure is not None:
            self._values["insecure"] = insecure
        if password is not None:
            self._values["password"] = password
        if port is not None:
            self._values["port"] = port
        if script_path is not None:
            self._values["script_path"] = script_path
        if timeout is not None:
            self._values["timeout"] = timeout
        if use_ntlm is not None:
            self._values["use_ntlm"] = use_ntlm
        if user is not None:
            self._values["user"] = user

    @builtins.property
    def host(self) -> builtins.str:
        '''(experimental) The address of the resource to connect to.

        :stability: experimental
        '''
        result = self._values.get("host")
        assert result is not None, "Required property 'host' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def type(self) -> builtins.str:
        '''(experimental) The connection type.

        Valid values are "ssh" and "winrm".
        Provisioners typically assume that the remote system runs Microsoft Windows when using WinRM.
        Behaviors based on the SSH target_platform will force Windows-specific behavior for WinRM, unless otherwise specified.

        :stability: experimental
        '''
        result = self._values.get("type")
        assert result is not None, "Required property 'type' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def cacert(self) -> typing.Optional[builtins.str]:
        '''(experimental) The CA certificate to validate against.

        :stability: experimental
        '''
        result = self._values.get("cacert")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def https(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Set to true to connect using HTTPS instead of HTTP.

        :stability: experimental
        '''
        result = self._values.get("https")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def insecure(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Set to true to skip validating the HTTPS certificate chain.

        :stability: experimental
        '''
        result = self._values.get("insecure")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def password(self) -> typing.Optional[builtins.str]:
        '''(experimental) The password to use for the connection.

        :stability: experimental
        '''
        result = self._values.get("password")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def port(self) -> typing.Optional[jsii.Number]:
        '''(experimental) The port to connect to.

        :default: 22

        :stability: experimental
        '''
        result = self._values.get("port")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def script_path(self) -> typing.Optional[builtins.str]:
        '''(experimental) The path used to copy scripts meant for remote execution.

        Refer to {@link https://developer.hashicorp.com/terraform/language/resources/provisioners/connection#how-provisioners-execute-remote-scripts How Provisioners Execute Remote Scripts below for more details}

        :stability: experimental
        '''
        result = self._values.get("script_path")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def timeout(self) -> typing.Optional[builtins.str]:
        '''(experimental) The timeout to wait for the connection to become available.

        Should be provided as a string (e.g., "30s" or "5m".)

        :default: 5m

        :stability: experimental
        '''
        result = self._values.get("timeout")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def use_ntlm(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Set to true to use NTLM authentication rather than default (basic authentication), removing the requirement for basic authentication to be enabled within the target guest.

        Refer to Authentication for Remote Connections in the Windows App Development documentation for more details.

        :stability: experimental
        '''
        result = self._values.get("use_ntlm")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def user(self) -> typing.Optional[builtins.str]:
        '''(experimental) The user to use for the connection.

        :default: root

        :stability: experimental
        '''
        result = self._values.get("user")
        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 "WinrmProvisionerConnection(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(ITerraformAddressable, IResolvable)
class AnyMap(metaclass=jsii.JSIIMeta, jsii_type="cdktn.AnyMap"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a22a11a22b1ca157a5e277d352bf3a37e3afaa03bdea4d45bc7997029918d5e6)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute])

    @jsii.member(jsii_name="computeFqn")
    def compute_fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "computeFqn", []))

    @jsii.member(jsii_name="lookup")
    def lookup(self, key: builtins.str) -> typing.Any:
        '''
        :param key: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5e47b50bf676da3ca39c48ee0a88853eb9e00d8bcaee821dbab5faee29a496fb)
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
        return typing.cast(typing.Any, jsii.invoke(self, "lookup", [key]))

    @jsii.member(jsii_name="resolve")
    def resolve(self, _context: IResolveContext) -> typing.Any:
        '''(experimental) Produce the Token's value at resolution time.

        :param _context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__08848319e8db762e31185da6ebbd74ff1f975827c2bbff040e382a7a87b20328)
            check_type(argname="argument _context", value=_context, expected_type=type_hints["_context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolve", [_context]))

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''(experimental) Return a string representation of this resolvable object.

        Returns a reversible string representation.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @builtins.property
    @jsii.member(jsii_name="creationStack")
    def creation_stack(self) -> typing.List[builtins.str]:
        '''(experimental) The creation stack of this resolvable which will be appended to errors thrown during resolution.

        If this returns an empty array the stack will not be attached.

        :stability: experimental
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "creationStack"))

    @builtins.property
    @jsii.member(jsii_name="fqn")
    def fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "fqn"))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__488a5e859020da9a5f9cd41c28e61c6dc22649daf02e5e4583c2febb82854d74)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__736d91502b2ab5ae4326febb1b5e1525ac8675c6729028f8933c719abc8817cd)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]


class AnyMapList(MapList, metaclass=jsii.JSIIMeta, jsii_type="cdktn.AnyMapList"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
        wraps_set: builtins.bool,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -
        :param wraps_set: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__32481cc58e63d8fc4832c4de265e5e382fbc84a2510799c6dc39925f21dab224)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
            check_type(argname="argument wraps_set", value=wraps_set, expected_type=type_hints["wraps_set"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute, wraps_set])

    @jsii.member(jsii_name="get")
    def get(self, index: jsii.Number) -> AnyMap:
        '''
        :param index: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e1b8830c59e83f9e994768458e11d29807357cc2aba44cb8c2351a44687a4d82)
            check_type(argname="argument index", value=index, expected_type=type_hints["index"])
        return typing.cast(AnyMap, jsii.invoke(self, "get", [index]))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__25684f881d675defc853a3dd766dbb2e484443cf71948682e4139b98ba013706)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d4a0dc743d561af4b57dfaa20280fe50ffcec0ecd4eb66809aa9b65a31f18abb)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="wrapsSet")
    def _wraps_set(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "wrapsSet"))

    @_wraps_set.setter
    def _wraps_set(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5e1f247f17760d242529b193426d35393d32b13993491b17a8d42c996cce8613)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "wrapsSet", value) # pyright: ignore[reportArgumentType]


@jsii.implements(ITerraformAddressable, IResolvable)
class BooleanMap(metaclass=jsii.JSIIMeta, jsii_type="cdktn.BooleanMap"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b4cbbedf36a8746a1d5c9c145d7b08835c4ba037baf7c170a739d514ac054c5d)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute])

    @jsii.member(jsii_name="computeFqn")
    def compute_fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "computeFqn", []))

    @jsii.member(jsii_name="lookup")
    def lookup(self, key: builtins.str) -> IResolvable:
        '''
        :param key: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1e28ef1add34483eefb5a70502005a3ae837b750e3106b38e57ec56356e69a4f)
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
        return typing.cast(IResolvable, jsii.invoke(self, "lookup", [key]))

    @jsii.member(jsii_name="resolve")
    def resolve(self, _context: IResolveContext) -> typing.Any:
        '''(experimental) Produce the Token's value at resolution time.

        :param _context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1ffc6974ca39c18d416f399dc0c56338b30103327c8e470612bcf3d374ec3a0a)
            check_type(argname="argument _context", value=_context, expected_type=type_hints["_context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolve", [_context]))

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''(experimental) Return a string representation of this resolvable object.

        Returns a reversible string representation.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @builtins.property
    @jsii.member(jsii_name="creationStack")
    def creation_stack(self) -> typing.List[builtins.str]:
        '''(experimental) The creation stack of this resolvable which will be appended to errors thrown during resolution.

        If this returns an empty array the stack will not be attached.

        :stability: experimental
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "creationStack"))

    @builtins.property
    @jsii.member(jsii_name="fqn")
    def fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "fqn"))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__217f59892af5234d1635b3be8389a24116ac71a2f2942146ee1eeba279155fc5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__187c7e3ac23a4127cda72763b630138a12a9e394e7b020118573e29c40bca0ff)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]


class BooleanMapList(
    MapList,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.BooleanMapList",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
        wraps_set: builtins.bool,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -
        :param wraps_set: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b612a5135fee22a20c547b9844f3ae29a2123eb6d1ba91abb7142c9ec4b74ab3)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
            check_type(argname="argument wraps_set", value=wraps_set, expected_type=type_hints["wraps_set"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute, wraps_set])

    @jsii.member(jsii_name="get")
    def get(self, index: jsii.Number) -> BooleanMap:
        '''
        :param index: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__096c48672b3a18aa12a074402f5f733fc4adc30de603ee69fe68825fb8df9b98)
            check_type(argname="argument index", value=index, expected_type=type_hints["index"])
        return typing.cast(BooleanMap, jsii.invoke(self, "get", [index]))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6202144644de57f47676d2529b8f11ce1978e14be46d6dd38d61005fdb80bd3c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a53cff012c477cff4b94cf595d52ea50e16f306c3c607472e124f005241bf080)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="wrapsSet")
    def _wraps_set(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "wrapsSet"))

    @_wraps_set.setter
    def _wraps_set(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ae11341a79bbd420fb007854cf069fe6d43cee030165e31290d50f14d6ac3eea)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "wrapsSet", value) # pyright: ignore[reportArgumentType]


@jsii.implements(IInterpolatingParent, IResolvable, ITerraformAddressable)
class ComplexComputedList(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.ComplexComputedList",
):
    '''
    :deprecated:

    Going to be replaced by Array of ComplexListItem
    and will be removed in the future

    :stability: deprecated
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
        complex_computed_list_index: builtins.str,
        wraps_set: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -
        :param complex_computed_list_index: -
        :param wraps_set: -

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__383f75d3115cefe50368b79b9cef65b6997c768310bb192c74f470cf288d8b78)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
            check_type(argname="argument complex_computed_list_index", value=complex_computed_list_index, expected_type=type_hints["complex_computed_list_index"])
            check_type(argname="argument wraps_set", value=wraps_set, expected_type=type_hints["wraps_set"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute, complex_computed_list_index, wraps_set])

    @jsii.member(jsii_name="computeFqn")
    def compute_fqn(self) -> builtins.str:
        '''
        :stability: deprecated
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "computeFqn", []))

    @jsii.member(jsii_name="getAnyMapAttribute")
    def get_any_map_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param terraform_attribute: -

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4fb6dcbc69fd65f6703422a86c29eb2022ee69c2441eb85d30d71ed42733d71f)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "getAnyMapAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getBooleanAttribute")
    def get_boolean_attribute(self, terraform_attribute: builtins.str) -> IResolvable:
        '''
        :param terraform_attribute: -

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b51a388054126c1a34441430434c576282d746019ed17a496bd1bc0b48c63854)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(IResolvable, jsii.invoke(self, "getBooleanAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getBooleanMapAttribute")
    def get_boolean_map_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, builtins.bool]:
        '''
        :param terraform_attribute: -

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f4355267962bb1cab5468b5fe64f339498113963dae8393cfa3a628bc2c256e4)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.Mapping[builtins.str, builtins.bool], jsii.invoke(self, "getBooleanMapAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getListAttribute")
    def get_list_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.List[builtins.str]:
        '''
        :param terraform_attribute: -

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e087b46276a638305f09d97b128411e040b9d3708738309d5064f708ef180196)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.List[builtins.str], jsii.invoke(self, "getListAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getNumberAttribute")
    def get_number_attribute(self, terraform_attribute: builtins.str) -> jsii.Number:
        '''
        :param terraform_attribute: -

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bd3534b896308b6bc094753e34ad68543ac61377f9fb518574fb8774fc6df8e6)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(jsii.Number, jsii.invoke(self, "getNumberAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getNumberListAttribute")
    def get_number_list_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.List[jsii.Number]:
        '''
        :param terraform_attribute: -

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c733078d1271b589e36d0388abee103b68a8f55b6f21958ebf12532e3a9d1bde)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.List[jsii.Number], jsii.invoke(self, "getNumberListAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getNumberMapAttribute")
    def get_number_map_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, jsii.Number]:
        '''
        :param terraform_attribute: -

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__502e2355b6b449ec72a612da44a983e2b183f207367b62a7abf487588698d4ab)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.Mapping[builtins.str, jsii.Number], jsii.invoke(self, "getNumberMapAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getStringAttribute")
    def get_string_attribute(self, terraform_attribute: builtins.str) -> builtins.str:
        '''
        :param terraform_attribute: -

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b94ac8353cc42e89b2bcd038497646cf633909f0a430bb020124e521d81e24d4)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(builtins.str, jsii.invoke(self, "getStringAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getStringMapAttribute")
    def get_string_map_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :param terraform_attribute: -

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__424d0fc7a63130c16f95c65b2372fed25ec89dcd78ed36b7992cf21a7d4cc6c9)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.invoke(self, "getStringMapAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="interpolationForAttribute")
    def interpolation_for_attribute(self, property: builtins.str) -> IResolvable:
        '''
        :param property: -

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5d83ede54fae28b8008111556e4786d0f4cf8b08f48b9daeb754f79a887838f8)
            check_type(argname="argument property", value=property, expected_type=type_hints["property"])
        return typing.cast(IResolvable, jsii.invoke(self, "interpolationForAttribute", [property]))

    @jsii.member(jsii_name="resolve")
    def resolve(self, _context: IResolveContext) -> typing.Any:
        '''(deprecated) Produce the Token's value at resolution time.

        :param _context: -

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8d21ac623c8f127f8545bbecebd93d169af32649a0cb5a291919fcad4b01e6a9)
            check_type(argname="argument _context", value=_context, expected_type=type_hints["_context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolve", [_context]))

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''(deprecated) Return a string representation of this resolvable object.

        Returns a reversible string representation.

        :stability: deprecated
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @builtins.property
    @jsii.member(jsii_name="creationStack")
    def creation_stack(self) -> typing.List[builtins.str]:
        '''(deprecated) The creation stack of this resolvable which will be appended to errors thrown during resolution.

        If this returns an empty array the stack will not be attached.

        :stability: deprecated
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "creationStack"))

    @builtins.property
    @jsii.member(jsii_name="fqn")
    def fqn(self) -> builtins.str:
        '''
        :stability: deprecated
        '''
        return typing.cast(builtins.str, jsii.get(self, "fqn"))

    @builtins.property
    @jsii.member(jsii_name="complexComputedListIndex")
    def _complex_computed_list_index(self) -> builtins.str:
        '''
        :stability: deprecated
        '''
        return typing.cast(builtins.str, jsii.get(self, "complexComputedListIndex"))

    @_complex_computed_list_index.setter
    def _complex_computed_list_index(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1d1c8f9c41869cb5909a15052228ba8713bce9d95823d5ea43f0b0c55910d9ba)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "complexComputedListIndex", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: deprecated
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ed23c4eff624f3f57109ef17cfb456635eae3342e1f23b93e8b8e00f62bd9466)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: deprecated
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__108c7f34d26f4752b0921ec0e278a4fc128f7defee7aeacd687475413ec74fa2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="wrapsSet")
    def _wraps_set(self) -> typing.Optional[builtins.bool]:
        '''
        :stability: deprecated
        '''
        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "wrapsSet"))

    @_wraps_set.setter
    def _wraps_set(self, value: typing.Optional[builtins.bool]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__38e4119708c882053c9fe3e3f097b88506a6097f11b2ad2563c78c9d6409f9b9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "wrapsSet", value) # pyright: ignore[reportArgumentType]


@jsii.implements(ITerraformAddressable, IResolvable)
class ComplexList(metaclass=jsii.JSIIAbstractClass, jsii_type="cdktn.ComplexList"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
        wraps_set: builtins.bool,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -
        :param wraps_set: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6be83ebe8558373d4bc8f4722aa69e58cae8a0946b2efb60ecbcd31c687e3671)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
            check_type(argname="argument wraps_set", value=wraps_set, expected_type=type_hints["wraps_set"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute, wraps_set])

    @jsii.member(jsii_name="allWithMapKey")
    def all_with_map_key(
        self,
        map_key_attribute_name: builtins.str,
    ) -> "DynamicListTerraformIterator":
        '''(experimental) Creating an iterator for this complex list.

        The list will be converted into a map with the mapKeyAttributeName as the key.

        :param map_key_attribute_name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d8614c54c88997387ce57251d8d4fba825a9bcda7f397e408b170cd8763fe949)
            check_type(argname="argument map_key_attribute_name", value=map_key_attribute_name, expected_type=type_hints["map_key_attribute_name"])
        return typing.cast("DynamicListTerraformIterator", jsii.invoke(self, "allWithMapKey", [map_key_attribute_name]))

    @jsii.member(jsii_name="computeFqn")
    def compute_fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "computeFqn", []))

    @jsii.member(jsii_name="resolve")
    def resolve(self, _context: IResolveContext) -> typing.Any:
        '''(experimental) Produce the Token's value at resolution time.

        :param _context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5d10780f0e7d635e94a953cca7fd0edaf91b68167e6c6cabae5f02639ce44172)
            check_type(argname="argument _context", value=_context, expected_type=type_hints["_context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolve", [_context]))

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''(experimental) Return a string representation of this resolvable object.

        Returns a reversible string representation.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @builtins.property
    @jsii.member(jsii_name="creationStack")
    def creation_stack(self) -> typing.List[builtins.str]:
        '''(experimental) The creation stack of this resolvable which will be appended to errors thrown during resolution.

        If this returns an empty array the stack will not be attached.

        :stability: experimental
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "creationStack"))

    @builtins.property
    @jsii.member(jsii_name="fqn")
    def fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "fqn"))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e6b976122321f9d313c28ca4b09636d876b74736955a100d2356f41bce797f89)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b93c5fde9deea93927dfda55a14707434f25cc66a12659395724b4c19c47ef07)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="wrapsSet")
    def _wraps_set(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "wrapsSet"))

    @_wraps_set.setter
    def _wraps_set(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4b99eaea79cb6ebec1931745b4c0b0638594b204cf7af324c07dbec4e5c2106f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "wrapsSet", value) # pyright: ignore[reportArgumentType]


class _ComplexListProxy(ComplexList):
    pass

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


@jsii.implements(ITerraformAddressable, IResolvable)
class ComplexMap(metaclass=jsii.JSIIAbstractClass, jsii_type="cdktn.ComplexMap"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c854ee500d97a0dbe62b21bcb07bbcc889a77bfba058310e8b73f83435b6f745)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute])

    @jsii.member(jsii_name="computeFqn")
    def compute_fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "computeFqn", []))

    @jsii.member(jsii_name="interpolationForAttribute")
    def interpolation_for_attribute(self, property: builtins.str) -> IResolvable:
        '''
        :param property: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ea17a3a77034c4a7c8405e27f7154aa0ceb5c68ac45ddf2bd37a41ec1fe5d8a1)
            check_type(argname="argument property", value=property, expected_type=type_hints["property"])
        return typing.cast(IResolvable, jsii.invoke(self, "interpolationForAttribute", [property]))

    @jsii.member(jsii_name="resolve")
    def resolve(self, _context: IResolveContext) -> typing.Any:
        '''(experimental) Produce the Token's value at resolution time.

        :param _context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fdd82e635edaf6d01515e7543eea9eef72b33dc9aa75f1cc543dd7e92e711545)
            check_type(argname="argument _context", value=_context, expected_type=type_hints["_context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolve", [_context]))

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''(experimental) Return a string representation of this resolvable object.

        Returns a reversible string representation.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @builtins.property
    @jsii.member(jsii_name="creationStack")
    def creation_stack(self) -> typing.List[builtins.str]:
        '''(experimental) The creation stack of this resolvable which will be appended to errors thrown during resolution.

        If this returns an empty array the stack will not be attached.

        :stability: experimental
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "creationStack"))

    @builtins.property
    @jsii.member(jsii_name="fqn")
    def fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "fqn"))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ce0ee068e409adcda85750a8f8befa59b8aa338867259ba0b745fc0c4045217d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4c21d5227b4f9b4595ce774d47fd776fd8d768233298e1f612b2220e2b7e5280)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]


class _ComplexMapProxy(ComplexMap):
    pass

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


@jsii.implements(IInterpolatingParent, IResolvable, ITerraformAddressable)
class ComplexObject(metaclass=jsii.JSIIMeta, jsii_type="cdktn.ComplexObject"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
        complex_object_is_from_set: builtins.bool,
        complex_object_index: typing.Optional[typing.Union[builtins.str, jsii.Number]] = None,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -
        :param complex_object_is_from_set: set to true if this item is from inside a set and needs tolist() for accessing it set to "0" for single list items.
        :param complex_object_index: the index of the complex object in a list.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__554b2fd9c18fe556ec0149ca5fa50e75fcbaec92b20820287b32e11980c21ecc)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
            check_type(argname="argument complex_object_is_from_set", value=complex_object_is_from_set, expected_type=type_hints["complex_object_is_from_set"])
            check_type(argname="argument complex_object_index", value=complex_object_index, expected_type=type_hints["complex_object_index"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute, complex_object_is_from_set, complex_object_index])

    @jsii.member(jsii_name="computeFqn")
    def compute_fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "computeFqn", []))

    @jsii.member(jsii_name="getAnyMapAttribute")
    def get_any_map_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a21d4876ff3c018327b09107b68512f52c6e4cdcdd1c0508a5491d777a271618)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "getAnyMapAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getBooleanAttribute")
    def get_boolean_attribute(self, terraform_attribute: builtins.str) -> IResolvable:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__545d7ac0b8723192b9e5c1406382f81ff1946904c3cfcd228e5f4e2eb8c24061)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(IResolvable, jsii.invoke(self, "getBooleanAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getBooleanMapAttribute")
    def get_boolean_map_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, builtins.bool]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e7de4e9f2af9699f78477597f3a017de22951080e6c512fa23e878404c8917d5)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.Mapping[builtins.str, builtins.bool], jsii.invoke(self, "getBooleanMapAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getListAttribute")
    def get_list_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.List[builtins.str]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c1520a48a34d5eb1b1840fa1e684bb24bd233c4f45ef6e8bbf41153f92ee3bf4)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.List[builtins.str], jsii.invoke(self, "getListAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getNumberAttribute")
    def get_number_attribute(self, terraform_attribute: builtins.str) -> jsii.Number:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fc81e22221531a52b27da0accde367cdb4d18596c0730bc23068cc6553d318ae)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(jsii.Number, jsii.invoke(self, "getNumberAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getNumberListAttribute")
    def get_number_list_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.List[jsii.Number]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fd93ecac5dc0e7c14bf391a91e27516c74ebf4921a9e0335926af3fe5533c38e)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.List[jsii.Number], jsii.invoke(self, "getNumberListAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getNumberMapAttribute")
    def get_number_map_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, jsii.Number]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__27428f33142f7e517042ae1b88d8530fdb605d84b12093452fa7e0847eae991b)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.Mapping[builtins.str, jsii.Number], jsii.invoke(self, "getNumberMapAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getStringAttribute")
    def get_string_attribute(self, terraform_attribute: builtins.str) -> builtins.str:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__43c03613002d1755242f5b0df91d39f1302fb396d469cade4dce632fb9746190)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(builtins.str, jsii.invoke(self, "getStringAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getStringMapAttribute")
    def get_string_map_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__af45ee76e652e37dbddd8c327c779045627cf95a7b49b167d41b7b6b147964a7)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.invoke(self, "getStringMapAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="interpolationAsList")
    def _interpolation_as_list(self) -> IResolvable:
        '''
        :stability: experimental
        '''
        return typing.cast(IResolvable, jsii.invoke(self, "interpolationAsList", []))

    @jsii.member(jsii_name="interpolationForAttribute")
    def interpolation_for_attribute(self, property: builtins.str) -> IResolvable:
        '''
        :param property: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c788899874d1a61570843ca1df12a114762a98eecdfa24770c7413ae18f19429)
            check_type(argname="argument property", value=property, expected_type=type_hints["property"])
        return typing.cast(IResolvable, jsii.invoke(self, "interpolationForAttribute", [property]))

    @jsii.member(jsii_name="resolve")
    def resolve(self, _context: IResolveContext) -> typing.Any:
        '''(experimental) Produce the Token's value at resolution time.

        :param _context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__292bb76f19e1a948c73ec009167906adec42237d61c77331fbddb681cde27be1)
            check_type(argname="argument _context", value=_context, expected_type=type_hints["_context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolve", [_context]))

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''(experimental) Return a string representation of this resolvable object.

        Returns a reversible string representation.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @builtins.property
    @jsii.member(jsii_name="creationStack")
    def creation_stack(self) -> typing.List[builtins.str]:
        '''(experimental) The creation stack of this resolvable which will be appended to errors thrown during resolution.

        If this returns an empty array the stack will not be attached.

        :stability: experimental
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "creationStack"))

    @builtins.property
    @jsii.member(jsii_name="fqn")
    def fqn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "fqn"))

    @builtins.property
    @jsii.member(jsii_name="complexObjectIsFromSet")
    def _complex_object_is_from_set(self) -> builtins.bool:
        '''(experimental) set to true if this item is from inside a set and needs tolist() for accessing it set to "0" for single list items.

        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "complexObjectIsFromSet"))

    @_complex_object_is_from_set.setter
    def _complex_object_is_from_set(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ba84737b1aaf2246be224622a461d7613d90fb85cf98ba3d77175c30d46db121)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "complexObjectIsFromSet", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eb74389644ae2bc5125e90abb07ddec96bf62bfa4c62492a467c91a99152369d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__55ac77e0ff614052ca7f96a7236bd5d019ab07fa92db574958fa75cdaa7c147b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="complexObjectIndex")
    def _complex_object_index(
        self,
    ) -> typing.Optional[typing.Union[builtins.str, jsii.Number]]:
        '''(experimental) the index of the complex object in a list.

        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[builtins.str, jsii.Number]], jsii.get(self, "complexObjectIndex"))

    @_complex_object_index.setter
    def _complex_object_index(
        self,
        value: typing.Optional[typing.Union[builtins.str, jsii.Number]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__07d6bb88b4f1626c232244085ff9d963adfe5257bbc190fe6081e9f5cb4adfc1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "complexObjectIndex", value) # pyright: ignore[reportArgumentType]


@jsii.data_type(
    jsii_type="cdktn.DataConfig",
    jsii_struct_bases=[TerraformMetaArguments],
    name_mapping={
        "connection": "connection",
        "count": "count",
        "depends_on": "dependsOn",
        "for_each": "forEach",
        "lifecycle": "lifecycle",
        "provider": "provider",
        "provisioners": "provisioners",
        "input": "input",
        "triggers_replace": "triggersReplace",
    },
)
class DataConfig(TerraformMetaArguments):
    def __init__(
        self,
        *,
        connection: typing.Optional[typing.Union[typing.Union[SSHProvisionerConnection, typing.Dict[builtins.str, typing.Any]], typing.Union[WinrmProvisionerConnection, typing.Dict[builtins.str, typing.Any]]]] = None,
        count: typing.Optional[typing.Union[jsii.Number, TerraformCount]] = None,
        depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
        for_each: typing.Optional[ITerraformIterator] = None,
        lifecycle: typing.Optional[typing.Union[TerraformResourceLifecycle, typing.Dict[builtins.str, typing.Any]]] = None,
        provider: typing.Optional[TerraformProvider] = None,
        provisioners: typing.Optional[typing.Sequence[typing.Union[typing.Union[FileProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[LocalExecProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[RemoteExecProvisioner, typing.Dict[builtins.str, typing.Any]]]]] = None,
        input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        triggers_replace: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    ) -> None:
        '''
        :param connection: 
        :param count: 
        :param depends_on: 
        :param for_each: 
        :param lifecycle: 
        :param provider: 
        :param provisioners: 
        :param input: (experimental) (Optional) A value which will be stored in the instance state, and reflected in the output attribute after apply. https://developer.hashicorp.com/terraform/language/resources/terraform-data#input
        :param triggers_replace: (experimental) (Optional) A value which is stored in the instance state, and will force replacement when the value changes. https://developer.hashicorp.com/terraform/language/resources/terraform-data#triggers_replace

        :stability: experimental
        '''
        if isinstance(lifecycle, dict):
            lifecycle = TerraformResourceLifecycle(**lifecycle)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__057c7d96213cc8ce7538cd2287db4e8fa4adaddbe87adb7a12ea3dd9a02bdcbb)
            check_type(argname="argument connection", value=connection, expected_type=type_hints["connection"])
            check_type(argname="argument count", value=count, expected_type=type_hints["count"])
            check_type(argname="argument depends_on", value=depends_on, expected_type=type_hints["depends_on"])
            check_type(argname="argument for_each", value=for_each, expected_type=type_hints["for_each"])
            check_type(argname="argument lifecycle", value=lifecycle, expected_type=type_hints["lifecycle"])
            check_type(argname="argument provider", value=provider, expected_type=type_hints["provider"])
            check_type(argname="argument provisioners", value=provisioners, expected_type=type_hints["provisioners"])
            check_type(argname="argument input", value=input, expected_type=type_hints["input"])
            check_type(argname="argument triggers_replace", value=triggers_replace, expected_type=type_hints["triggers_replace"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if connection is not None:
            self._values["connection"] = connection
        if count is not None:
            self._values["count"] = count
        if depends_on is not None:
            self._values["depends_on"] = depends_on
        if for_each is not None:
            self._values["for_each"] = for_each
        if lifecycle is not None:
            self._values["lifecycle"] = lifecycle
        if provider is not None:
            self._values["provider"] = provider
        if provisioners is not None:
            self._values["provisioners"] = provisioners
        if input is not None:
            self._values["input"] = input
        if triggers_replace is not None:
            self._values["triggers_replace"] = triggers_replace

    @builtins.property
    def connection(
        self,
    ) -> typing.Optional[typing.Union[SSHProvisionerConnection, WinrmProvisionerConnection]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("connection")
        return typing.cast(typing.Optional[typing.Union[SSHProvisionerConnection, WinrmProvisionerConnection]], result)

    @builtins.property
    def count(self) -> typing.Optional[typing.Union[jsii.Number, TerraformCount]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("count")
        return typing.cast(typing.Optional[typing.Union[jsii.Number, TerraformCount]], result)

    @builtins.property
    def depends_on(self) -> typing.Optional[typing.List[ITerraformDependable]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("depends_on")
        return typing.cast(typing.Optional[typing.List[ITerraformDependable]], result)

    @builtins.property
    def for_each(self) -> typing.Optional[ITerraformIterator]:
        '''
        :stability: experimental
        '''
        result = self._values.get("for_each")
        return typing.cast(typing.Optional[ITerraformIterator], result)

    @builtins.property
    def lifecycle(self) -> typing.Optional[TerraformResourceLifecycle]:
        '''
        :stability: experimental
        '''
        result = self._values.get("lifecycle")
        return typing.cast(typing.Optional[TerraformResourceLifecycle], result)

    @builtins.property
    def provider(self) -> typing.Optional[TerraformProvider]:
        '''
        :stability: experimental
        '''
        result = self._values.get("provider")
        return typing.cast(typing.Optional[TerraformProvider], result)

    @builtins.property
    def provisioners(
        self,
    ) -> typing.Optional[typing.List[typing.Union[FileProvisioner, LocalExecProvisioner, RemoteExecProvisioner]]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("provisioners")
        return typing.cast(typing.Optional[typing.List[typing.Union[FileProvisioner, LocalExecProvisioner, RemoteExecProvisioner]]], result)

    @builtins.property
    def input(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) (Optional) A value which will be stored in the instance state, and reflected in the output attribute after apply.

        https://developer.hashicorp.com/terraform/language/resources/terraform-data#input

        :stability: experimental
        '''
        result = self._values.get("input")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def triggers_replace(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) (Optional) A value which is stored in the instance state, and will force replacement when the value changes.

        https://developer.hashicorp.com/terraform/language/resources/terraform-data#triggers_replace

        :stability: experimental
        '''
        result = self._values.get("triggers_replace")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], 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 "DataConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class DataResource(
    TerraformResource,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.DataResource",
):
    '''(experimental) The DataResource implements the standard resource lifecycle, but does not directly take any other actions.

    You can use the DataResource resource without requiring or configuring a provider.

    The DataResource resource is useful for storing values which need to follow a manage resource lifecycle, and for triggering provisioners when there is no other logical managed resource in which to place them.

    It requires Terraform 1.4 or later.

    It is also possible to generate these bindings by adding "terraform.io/builtin/terraform" to the "terraformProviders" key in your cdktf.json file and running "cdktn get".

    https://developer.hashicorp.com/terraform/language/resources/terraform-data

    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        triggers_replace: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        connection: typing.Optional[typing.Union[typing.Union[SSHProvisionerConnection, typing.Dict[builtins.str, typing.Any]], typing.Union[WinrmProvisionerConnection, typing.Dict[builtins.str, typing.Any]]]] = None,
        count: typing.Optional[typing.Union[jsii.Number, TerraformCount]] = None,
        depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
        for_each: typing.Optional[ITerraformIterator] = None,
        lifecycle: typing.Optional[typing.Union[TerraformResourceLifecycle, typing.Dict[builtins.str, typing.Any]]] = None,
        provider: typing.Optional[TerraformProvider] = None,
        provisioners: typing.Optional[typing.Sequence[typing.Union[typing.Union[FileProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[LocalExecProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[RemoteExecProvisioner, typing.Dict[builtins.str, typing.Any]]]]] = None,
    ) -> None:
        '''(experimental) Create a new TerraformData Resource.

        The DataResource resource is useful for storing values which need to follow a manage resource lifecycle, and for triggering provisioners when there is no other logical managed resource in which to place them.

        :param scope: The scope in which to define this construct.
        :param id: The scoped construct ID. Must be unique amongst siblings in the same scope
        :param input: (experimental) (Optional) A value which will be stored in the instance state, and reflected in the output attribute after apply. https://developer.hashicorp.com/terraform/language/resources/terraform-data#input
        :param triggers_replace: (experimental) (Optional) A value which is stored in the instance state, and will force replacement when the value changes. https://developer.hashicorp.com/terraform/language/resources/terraform-data#triggers_replace
        :param connection: 
        :param count: 
        :param depends_on: 
        :param for_each: 
        :param lifecycle: 
        :param provider: 
        :param provisioners: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__53ee2b83542d7e9f32ef416d97e9f6cd35cfafe3e01a6da0cf938ea287c399d5)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = DataConfig(
            input=input,
            triggers_replace=triggers_replace,
            connection=connection,
            count=count,
            depends_on=depends_on,
            for_each=for_each,
            lifecycle=lifecycle,
            provider=provider,
            provisioners=provisioners,
        )

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

    @jsii.member(jsii_name="generateConfigForImport")
    @builtins.classmethod
    def generate_config_for_import(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        import_to_id: builtins.str,
        import_from_id: builtins.str,
        provider: typing.Optional[TerraformProvider] = None,
    ) -> "ImportableResource":
        '''(experimental) Generates CDKTN code for importing a Data resource upon running "cdktn plan ".

        :param scope: The scope in which to define this construct.
        :param import_to_id: The construct id used in the generated config for the Data to import.
        :param import_from_id: The id of the existing Data that should be imported. Refer to the {@link https://terraform.io/providers/builtin/terraform/latest/docs/resources/data#import import section} in the documentation of this resource for the id to use
        :param provider: ? Optional instance of the provider where the Data to import is found.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dba84ace82fde4eaf7e4c14b3080ce0b866a28f83d1f27af60cc2583f6dc9e37)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument import_to_id", value=import_to_id, expected_type=type_hints["import_to_id"])
            check_type(argname="argument import_from_id", value=import_from_id, expected_type=type_hints["import_from_id"])
            check_type(argname="argument provider", value=provider, expected_type=type_hints["provider"])
        return typing.cast("ImportableResource", jsii.sinvoke(cls, "generateConfigForImport", [scope, import_to_id, import_from_id, provider]))

    @jsii.member(jsii_name="resetInput")
    def reset_input(self) -> None:
        '''
        :stability: experimental
        '''
        return typing.cast(None, jsii.invoke(self, "resetInput", []))

    @jsii.member(jsii_name="resetTriggersReplace")
    def reset_triggers_replace(self) -> None:
        '''
        :stability: experimental
        '''
        return typing.cast(None, jsii.invoke(self, "resetTriggersReplace", []))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))

    @jsii.python.classproperty
    @jsii.member(jsii_name="tfResourceType")
    def TF_RESOURCE_TYPE(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "tfResourceType"))

    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "id"))

    @builtins.property
    @jsii.member(jsii_name="output")
    def output(self) -> AnyMap:
        '''
        :stability: experimental
        '''
        return typing.cast(AnyMap, jsii.get(self, "output"))

    @builtins.property
    @jsii.member(jsii_name="inputInput")
    def input_input(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], jsii.get(self, "inputInput"))

    @builtins.property
    @jsii.member(jsii_name="triggersReplaceInput")
    def triggers_replace_input(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], jsii.get(self, "triggersReplaceInput"))

    @builtins.property
    @jsii.member(jsii_name="input")
    def input(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''(experimental) (Optional) A value which will be stored in the instance state, and reflected in the output attribute after apply.

        https://developer.hashicorp.com/terraform/language/resources/terraform-data#input

        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "input"))

    @input.setter
    def input(self, value: typing.Mapping[builtins.str, typing.Any]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5d16227f257dbd5d33c5e910ea4d33e209766fb155a3a21622e834a579eb002b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "input", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="triggersReplace")
    def triggers_replace(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''(experimental) (Optional) A value which is stored in the instance state, and will force replacement when the value changes.

        https://developer.hashicorp.com/terraform/language/resources/terraform-data#triggers_replace

        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "triggersReplace"))

    @triggers_replace.setter
    def triggers_replace(self, value: typing.Mapping[builtins.str, typing.Any]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1a15568f1d7619b5b53e1d0d7039e1949214f9049bc31935adab5c586f774eba)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "triggersReplace", value) # pyright: ignore[reportArgumentType]


class DataTerraformRemoteState(
    TerraformRemoteState,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.DataTerraformRemoteState",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        organization: builtins.str,
        workspaces: IRemoteWorkspace,
        hostname: typing.Optional[builtins.str] = None,
        token: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param defaults: 
        :param workspace: 
        :param organization: 
        :param workspaces: 
        :param hostname: 
        :param token: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__863f037dc57c8bbc6ef45a85f5789f9a5b59652a9af40192ebcebbe49aa2fc75)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = DataTerraformRemoteStateRemoteConfig(
            defaults=defaults,
            workspace=workspace,
            organization=organization,
            workspaces=workspaces,
            hostname=hostname,
            token=token,
        )

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


class DataTerraformRemoteStateAzurerm(
    TerraformRemoteState,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.DataTerraformRemoteStateAzurerm",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        container_name: builtins.str,
        key: builtins.str,
        storage_account_name: builtins.str,
        access_key: typing.Optional[builtins.str] = None,
        client_certificate_password: typing.Optional[builtins.str] = None,
        client_certificate_path: typing.Optional[builtins.str] = None,
        client_id: typing.Optional[builtins.str] = None,
        client_secret: typing.Optional[builtins.str] = None,
        endpoint: typing.Optional[builtins.str] = None,
        environment: typing.Optional[builtins.str] = None,
        metadata_host: typing.Optional[builtins.str] = None,
        msi_endpoint: typing.Optional[builtins.str] = None,
        oidc_request_token: typing.Optional[builtins.str] = None,
        oidc_request_url: typing.Optional[builtins.str] = None,
        oidc_token: typing.Optional[builtins.str] = None,
        oidc_token_file_path: typing.Optional[builtins.str] = None,
        resource_group_name: typing.Optional[builtins.str] = None,
        sas_token: typing.Optional[builtins.str] = None,
        snapshot: typing.Optional[builtins.bool] = None,
        subscription_id: typing.Optional[builtins.str] = None,
        tenant_id: typing.Optional[builtins.str] = None,
        use_azuread_auth: typing.Optional[builtins.bool] = None,
        use_microsoft_graph: typing.Optional[builtins.bool] = None,
        use_msi: typing.Optional[builtins.bool] = None,
        use_oidc: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param defaults: 
        :param workspace: 
        :param container_name: (experimental) (Required) The Name of the Storage Container within the Storage Account.
        :param key: (experimental) (Required) The name of the Blob used to retrieve/store Terraform's State file inside the Storage Container.
        :param storage_account_name: (experimental) (Required) The Name of the Storage Account.
        :param access_key: (experimental) access_key - (Optional) The Access Key used to access the Blob Storage Account. This can also be sourced from the ARM_ACCESS_KEY environment variable.
        :param client_certificate_password: (experimental) (Optional) The password associated with the Client Certificate specified in client_certificate_path. This can also be sourced from the ARM_CLIENT_CERTIFICATE_PASSWORD environment variable.
        :param client_certificate_path: (experimental) (Optional) The path to the PFX file used as the Client Certificate when authenticating as a Service Principal. This can also be sourced from the ARM_CLIENT_CERTIFICATE_PATH environment variable.
        :param client_id: (experimental) (Optional) The Client ID of the Service Principal. This can also be sourced from the ARM_CLIENT_ID environment variable.
        :param client_secret: (experimental) (Optional) The Client Secret of the Service Principal. This can also be sourced from the ARM_CLIENT_SECRET environment variable.
        :param endpoint: (experimental) (Optional) The Custom Endpoint for Azure Resource Manager. This can also be sourced from the ARM_ENDPOINT environment variable. NOTE: An endpoint should only be configured when using Azure Stack.
        :param environment: (experimental) (Optional) The Azure Environment which should be used. This can also be sourced from the ARM_ENVIRONMENT environment variable. Possible values are public, china, german, stack and usgovernment. Defaults to public.
        :param metadata_host: (experimental) (Optional) The Hostname of the Azure Metadata Service (for example management.azure.com), used to obtain the Cloud Environment when using a Custom Azure Environment. This can also be sourced from the ARM_METADATA_HOSTNAME Environment Variable.).
        :param msi_endpoint: (experimental) (Optional) The path to a custom Managed Service Identity endpoint which is automatically determined if not specified. This can also be sourced from the ARM_MSI_ENDPOINT environment variable.
        :param oidc_request_token: (experimental) (Optional) The bearer token for the request to the OIDC provider. This can also be sourced from the ARM_OIDC_REQUEST_TOKEN or ACTIONS_ID_TOKEN_REQUEST_TOKEN environment variables.
        :param oidc_request_url: (experimental) (Optional) The URL for the OIDC provider from which to request an ID token. This can also be sourced from the ARM_OIDC_REQUEST_URL or ACTIONS_ID_TOKEN_REQUEST_URL environment variables.
        :param oidc_token: (experimental) (Optional) The ID token when authenticating using OpenID Connect (OIDC). This can also be sourced from the ARM_OIDC_TOKEN environment variable.
        :param oidc_token_file_path: (experimental) (Optional) The path to a file containing an ID token when authenticating using OpenID Connect (OIDC). This can also be sourced from the ARM_OIDC_TOKEN_FILE_PATH environment variable.
        :param resource_group_name: (experimental) (Required) The Name of the Resource Group in which the Storage Account exists.
        :param sas_token: (experimental) (Optional) The SAS Token used to access the Blob Storage Account. This can also be sourced from the ARM_SAS_TOKEN environment variable.
        :param snapshot: (experimental) (Optional) Should the Blob used to store the Terraform Statefile be snapshotted before use? Defaults to false. This value can also be sourced from the ARM_SNAPSHOT environment variable.
        :param subscription_id: (experimental) (Optional) The Subscription ID in which the Storage Account exists. This can also be sourced from the ARM_SUBSCRIPTION_ID environment variable.
        :param tenant_id: (experimental) (Optional) The Tenant ID in which the Subscription exists. This can also be sourced from the ARM_TENANT_ID environment variable.
        :param use_azuread_auth: (experimental) (Optional) Should AzureAD Authentication be used to access the Blob Storage Account. This can also be sourced from the ARM_USE_AZUREAD environment variable. Note: When using AzureAD for Authentication to Storage you also need to ensure the Storage Blob Data Owner role is assigned.
        :param use_microsoft_graph: (experimental) (Optional) Should MSAL be used for authentication instead of ADAL, and should Microsoft Graph be used instead of Azure Active Directory Graph? Defaults to true. Note: In Terraform 1.2 the Azure Backend uses MSAL (and Microsoft Graph) rather than ADAL (and Azure Active Directory Graph) for authentication by default - you can disable this by setting use_microsoft_graph to false. This setting will be removed in Terraform 1.3, due to Microsoft's deprecation of ADAL.
        :param use_msi: (experimental) (Optional) Should Managed Service Identity authentication be used? This can also be sourced from the ARM_USE_MSI environment variable.
        :param use_oidc: (experimental) (Optional) Should OIDC authentication be used? This can also be sourced from the ARM_USE_OIDC environment variable. Note: When using OIDC for authentication, use_microsoft_graph must be set to true (which is the default).

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d36f36687c8298603d4abc2d50db09a4d3fa5fc329fd72fe8b79da898af21010)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = DataTerraformRemoteStateAzurermConfig(
            defaults=defaults,
            workspace=workspace,
            container_name=container_name,
            key=key,
            storage_account_name=storage_account_name,
            access_key=access_key,
            client_certificate_password=client_certificate_password,
            client_certificate_path=client_certificate_path,
            client_id=client_id,
            client_secret=client_secret,
            endpoint=endpoint,
            environment=environment,
            metadata_host=metadata_host,
            msi_endpoint=msi_endpoint,
            oidc_request_token=oidc_request_token,
            oidc_request_url=oidc_request_url,
            oidc_token=oidc_token,
            oidc_token_file_path=oidc_token_file_path,
            resource_group_name=resource_group_name,
            sas_token=sas_token,
            snapshot=snapshot,
            subscription_id=subscription_id,
            tenant_id=tenant_id,
            use_azuread_auth=use_azuread_auth,
            use_microsoft_graph=use_microsoft_graph,
            use_msi=use_msi,
            use_oidc=use_oidc,
        )

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


@jsii.data_type(
    jsii_type="cdktn.DataTerraformRemoteStateAzurermConfig",
    jsii_struct_bases=[DataTerraformRemoteStateConfig, AzurermBackendConfig],
    name_mapping={
        "defaults": "defaults",
        "workspace": "workspace",
        "container_name": "containerName",
        "key": "key",
        "storage_account_name": "storageAccountName",
        "access_key": "accessKey",
        "client_certificate_password": "clientCertificatePassword",
        "client_certificate_path": "clientCertificatePath",
        "client_id": "clientId",
        "client_secret": "clientSecret",
        "endpoint": "endpoint",
        "environment": "environment",
        "metadata_host": "metadataHost",
        "msi_endpoint": "msiEndpoint",
        "oidc_request_token": "oidcRequestToken",
        "oidc_request_url": "oidcRequestUrl",
        "oidc_token": "oidcToken",
        "oidc_token_file_path": "oidcTokenFilePath",
        "resource_group_name": "resourceGroupName",
        "sas_token": "sasToken",
        "snapshot": "snapshot",
        "subscription_id": "subscriptionId",
        "tenant_id": "tenantId",
        "use_azuread_auth": "useAzureadAuth",
        "use_microsoft_graph": "useMicrosoftGraph",
        "use_msi": "useMsi",
        "use_oidc": "useOidc",
    },
)
class DataTerraformRemoteStateAzurermConfig(
    DataTerraformRemoteStateConfig,
    AzurermBackendConfig,
):
    def __init__(
        self,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        container_name: builtins.str,
        key: builtins.str,
        storage_account_name: builtins.str,
        access_key: typing.Optional[builtins.str] = None,
        client_certificate_password: typing.Optional[builtins.str] = None,
        client_certificate_path: typing.Optional[builtins.str] = None,
        client_id: typing.Optional[builtins.str] = None,
        client_secret: typing.Optional[builtins.str] = None,
        endpoint: typing.Optional[builtins.str] = None,
        environment: typing.Optional[builtins.str] = None,
        metadata_host: typing.Optional[builtins.str] = None,
        msi_endpoint: typing.Optional[builtins.str] = None,
        oidc_request_token: typing.Optional[builtins.str] = None,
        oidc_request_url: typing.Optional[builtins.str] = None,
        oidc_token: typing.Optional[builtins.str] = None,
        oidc_token_file_path: typing.Optional[builtins.str] = None,
        resource_group_name: typing.Optional[builtins.str] = None,
        sas_token: typing.Optional[builtins.str] = None,
        snapshot: typing.Optional[builtins.bool] = None,
        subscription_id: typing.Optional[builtins.str] = None,
        tenant_id: typing.Optional[builtins.str] = None,
        use_azuread_auth: typing.Optional[builtins.bool] = None,
        use_microsoft_graph: typing.Optional[builtins.bool] = None,
        use_msi: typing.Optional[builtins.bool] = None,
        use_oidc: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param defaults: 
        :param workspace: 
        :param container_name: (experimental) (Required) The Name of the Storage Container within the Storage Account.
        :param key: (experimental) (Required) The name of the Blob used to retrieve/store Terraform's State file inside the Storage Container.
        :param storage_account_name: (experimental) (Required) The Name of the Storage Account.
        :param access_key: (experimental) access_key - (Optional) The Access Key used to access the Blob Storage Account. This can also be sourced from the ARM_ACCESS_KEY environment variable.
        :param client_certificate_password: (experimental) (Optional) The password associated with the Client Certificate specified in client_certificate_path. This can also be sourced from the ARM_CLIENT_CERTIFICATE_PASSWORD environment variable.
        :param client_certificate_path: (experimental) (Optional) The path to the PFX file used as the Client Certificate when authenticating as a Service Principal. This can also be sourced from the ARM_CLIENT_CERTIFICATE_PATH environment variable.
        :param client_id: (experimental) (Optional) The Client ID of the Service Principal. This can also be sourced from the ARM_CLIENT_ID environment variable.
        :param client_secret: (experimental) (Optional) The Client Secret of the Service Principal. This can also be sourced from the ARM_CLIENT_SECRET environment variable.
        :param endpoint: (experimental) (Optional) The Custom Endpoint for Azure Resource Manager. This can also be sourced from the ARM_ENDPOINT environment variable. NOTE: An endpoint should only be configured when using Azure Stack.
        :param environment: (experimental) (Optional) The Azure Environment which should be used. This can also be sourced from the ARM_ENVIRONMENT environment variable. Possible values are public, china, german, stack and usgovernment. Defaults to public.
        :param metadata_host: (experimental) (Optional) The Hostname of the Azure Metadata Service (for example management.azure.com), used to obtain the Cloud Environment when using a Custom Azure Environment. This can also be sourced from the ARM_METADATA_HOSTNAME Environment Variable.).
        :param msi_endpoint: (experimental) (Optional) The path to a custom Managed Service Identity endpoint which is automatically determined if not specified. This can also be sourced from the ARM_MSI_ENDPOINT environment variable.
        :param oidc_request_token: (experimental) (Optional) The bearer token for the request to the OIDC provider. This can also be sourced from the ARM_OIDC_REQUEST_TOKEN or ACTIONS_ID_TOKEN_REQUEST_TOKEN environment variables.
        :param oidc_request_url: (experimental) (Optional) The URL for the OIDC provider from which to request an ID token. This can also be sourced from the ARM_OIDC_REQUEST_URL or ACTIONS_ID_TOKEN_REQUEST_URL environment variables.
        :param oidc_token: (experimental) (Optional) The ID token when authenticating using OpenID Connect (OIDC). This can also be sourced from the ARM_OIDC_TOKEN environment variable.
        :param oidc_token_file_path: (experimental) (Optional) The path to a file containing an ID token when authenticating using OpenID Connect (OIDC). This can also be sourced from the ARM_OIDC_TOKEN_FILE_PATH environment variable.
        :param resource_group_name: (experimental) (Required) The Name of the Resource Group in which the Storage Account exists.
        :param sas_token: (experimental) (Optional) The SAS Token used to access the Blob Storage Account. This can also be sourced from the ARM_SAS_TOKEN environment variable.
        :param snapshot: (experimental) (Optional) Should the Blob used to store the Terraform Statefile be snapshotted before use? Defaults to false. This value can also be sourced from the ARM_SNAPSHOT environment variable.
        :param subscription_id: (experimental) (Optional) The Subscription ID in which the Storage Account exists. This can also be sourced from the ARM_SUBSCRIPTION_ID environment variable.
        :param tenant_id: (experimental) (Optional) The Tenant ID in which the Subscription exists. This can also be sourced from the ARM_TENANT_ID environment variable.
        :param use_azuread_auth: (experimental) (Optional) Should AzureAD Authentication be used to access the Blob Storage Account. This can also be sourced from the ARM_USE_AZUREAD environment variable. Note: When using AzureAD for Authentication to Storage you also need to ensure the Storage Blob Data Owner role is assigned.
        :param use_microsoft_graph: (experimental) (Optional) Should MSAL be used for authentication instead of ADAL, and should Microsoft Graph be used instead of Azure Active Directory Graph? Defaults to true. Note: In Terraform 1.2 the Azure Backend uses MSAL (and Microsoft Graph) rather than ADAL (and Azure Active Directory Graph) for authentication by default - you can disable this by setting use_microsoft_graph to false. This setting will be removed in Terraform 1.3, due to Microsoft's deprecation of ADAL.
        :param use_msi: (experimental) (Optional) Should Managed Service Identity authentication be used? This can also be sourced from the ARM_USE_MSI environment variable.
        :param use_oidc: (experimental) (Optional) Should OIDC authentication be used? This can also be sourced from the ARM_USE_OIDC environment variable. Note: When using OIDC for authentication, use_microsoft_graph must be set to true (which is the default).

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__da44dc0bd9c6e94fe3ca5295fddc0180a8970650564e1c8f0a45037648494ddd)
            check_type(argname="argument defaults", value=defaults, expected_type=type_hints["defaults"])
            check_type(argname="argument workspace", value=workspace, expected_type=type_hints["workspace"])
            check_type(argname="argument container_name", value=container_name, expected_type=type_hints["container_name"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
            check_type(argname="argument storage_account_name", value=storage_account_name, expected_type=type_hints["storage_account_name"])
            check_type(argname="argument access_key", value=access_key, expected_type=type_hints["access_key"])
            check_type(argname="argument client_certificate_password", value=client_certificate_password, expected_type=type_hints["client_certificate_password"])
            check_type(argname="argument client_certificate_path", value=client_certificate_path, expected_type=type_hints["client_certificate_path"])
            check_type(argname="argument client_id", value=client_id, expected_type=type_hints["client_id"])
            check_type(argname="argument client_secret", value=client_secret, expected_type=type_hints["client_secret"])
            check_type(argname="argument endpoint", value=endpoint, expected_type=type_hints["endpoint"])
            check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
            check_type(argname="argument metadata_host", value=metadata_host, expected_type=type_hints["metadata_host"])
            check_type(argname="argument msi_endpoint", value=msi_endpoint, expected_type=type_hints["msi_endpoint"])
            check_type(argname="argument oidc_request_token", value=oidc_request_token, expected_type=type_hints["oidc_request_token"])
            check_type(argname="argument oidc_request_url", value=oidc_request_url, expected_type=type_hints["oidc_request_url"])
            check_type(argname="argument oidc_token", value=oidc_token, expected_type=type_hints["oidc_token"])
            check_type(argname="argument oidc_token_file_path", value=oidc_token_file_path, expected_type=type_hints["oidc_token_file_path"])
            check_type(argname="argument resource_group_name", value=resource_group_name, expected_type=type_hints["resource_group_name"])
            check_type(argname="argument sas_token", value=sas_token, expected_type=type_hints["sas_token"])
            check_type(argname="argument snapshot", value=snapshot, expected_type=type_hints["snapshot"])
            check_type(argname="argument subscription_id", value=subscription_id, expected_type=type_hints["subscription_id"])
            check_type(argname="argument tenant_id", value=tenant_id, expected_type=type_hints["tenant_id"])
            check_type(argname="argument use_azuread_auth", value=use_azuread_auth, expected_type=type_hints["use_azuread_auth"])
            check_type(argname="argument use_microsoft_graph", value=use_microsoft_graph, expected_type=type_hints["use_microsoft_graph"])
            check_type(argname="argument use_msi", value=use_msi, expected_type=type_hints["use_msi"])
            check_type(argname="argument use_oidc", value=use_oidc, expected_type=type_hints["use_oidc"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "container_name": container_name,
            "key": key,
            "storage_account_name": storage_account_name,
        }
        if defaults is not None:
            self._values["defaults"] = defaults
        if workspace is not None:
            self._values["workspace"] = workspace
        if access_key is not None:
            self._values["access_key"] = access_key
        if client_certificate_password is not None:
            self._values["client_certificate_password"] = client_certificate_password
        if client_certificate_path is not None:
            self._values["client_certificate_path"] = client_certificate_path
        if client_id is not None:
            self._values["client_id"] = client_id
        if client_secret is not None:
            self._values["client_secret"] = client_secret
        if endpoint is not None:
            self._values["endpoint"] = endpoint
        if environment is not None:
            self._values["environment"] = environment
        if metadata_host is not None:
            self._values["metadata_host"] = metadata_host
        if msi_endpoint is not None:
            self._values["msi_endpoint"] = msi_endpoint
        if oidc_request_token is not None:
            self._values["oidc_request_token"] = oidc_request_token
        if oidc_request_url is not None:
            self._values["oidc_request_url"] = oidc_request_url
        if oidc_token is not None:
            self._values["oidc_token"] = oidc_token
        if oidc_token_file_path is not None:
            self._values["oidc_token_file_path"] = oidc_token_file_path
        if resource_group_name is not None:
            self._values["resource_group_name"] = resource_group_name
        if sas_token is not None:
            self._values["sas_token"] = sas_token
        if snapshot is not None:
            self._values["snapshot"] = snapshot
        if subscription_id is not None:
            self._values["subscription_id"] = subscription_id
        if tenant_id is not None:
            self._values["tenant_id"] = tenant_id
        if use_azuread_auth is not None:
            self._values["use_azuread_auth"] = use_azuread_auth
        if use_microsoft_graph is not None:
            self._values["use_microsoft_graph"] = use_microsoft_graph
        if use_msi is not None:
            self._values["use_msi"] = use_msi
        if use_oidc is not None:
            self._values["use_oidc"] = use_oidc

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

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

    @builtins.property
    def container_name(self) -> builtins.str:
        '''(experimental) (Required) The Name of the Storage Container within the Storage Account.

        :stability: experimental
        '''
        result = self._values.get("container_name")
        assert result is not None, "Required property 'container_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def key(self) -> builtins.str:
        '''(experimental) (Required) The name of the Blob used to retrieve/store Terraform's State file inside the Storage Container.

        :stability: experimental
        '''
        result = self._values.get("key")
        assert result is not None, "Required property 'key' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def storage_account_name(self) -> builtins.str:
        '''(experimental) (Required) The Name of the Storage Account.

        :stability: experimental
        '''
        result = self._values.get("storage_account_name")
        assert result is not None, "Required property 'storage_account_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def access_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) access_key - (Optional) The Access Key used to access the Blob Storage Account.

        This can also be sourced from the ARM_ACCESS_KEY environment variable.

        :stability: experimental
        '''
        result = self._values.get("access_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def client_certificate_password(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The password associated with the Client Certificate specified in client_certificate_path.

        This can also be sourced from the
        ARM_CLIENT_CERTIFICATE_PASSWORD environment variable.

        :stability: experimental
        '''
        result = self._values.get("client_certificate_password")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def client_certificate_path(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The path to the PFX file used as the Client Certificate when authenticating as a Service Principal.

        This can also be sourced from the
        ARM_CLIENT_CERTIFICATE_PATH environment variable.

        :stability: experimental
        '''
        result = self._values.get("client_certificate_path")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def client_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The Client ID of the Service Principal.

        This can also be sourced from the ARM_CLIENT_ID environment variable.

        :stability: experimental
        '''
        result = self._values.get("client_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def client_secret(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The Client Secret of the Service Principal.

        This can also be sourced from the ARM_CLIENT_SECRET environment variable.

        :stability: experimental
        '''
        result = self._values.get("client_secret")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The Custom Endpoint for Azure Resource Manager. This can also be sourced from the ARM_ENDPOINT environment variable.

        NOTE: An endpoint should only be configured when using Azure Stack.

        :stability: experimental
        '''
        result = self._values.get("endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def environment(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The Azure Environment which should be used.

        This can also be sourced from the ARM_ENVIRONMENT environment variable.
        Possible values are public, china, german, stack and usgovernment. Defaults to public.

        :stability: experimental
        '''
        result = self._values.get("environment")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def metadata_host(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The Hostname of the Azure Metadata Service (for example management.azure.com), used to obtain the Cloud Environment when using a Custom Azure Environment. This can also be sourced from the ARM_METADATA_HOSTNAME Environment Variable.).

        :stability: experimental
        '''
        result = self._values.get("metadata_host")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def msi_endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The path to a custom Managed Service Identity endpoint which is automatically determined if not specified.

        This can also be sourced from the ARM_MSI_ENDPOINT environment variable.

        :stability: experimental
        '''
        result = self._values.get("msi_endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def oidc_request_token(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The bearer token for the request to the OIDC provider.

        This can
        also be sourced from the ARM_OIDC_REQUEST_TOKEN or
        ACTIONS_ID_TOKEN_REQUEST_TOKEN environment variables.

        :stability: experimental
        '''
        result = self._values.get("oidc_request_token")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def oidc_request_url(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The URL for the OIDC provider from which to request an ID token.

        This can also be sourced from the ARM_OIDC_REQUEST_URL or
        ACTIONS_ID_TOKEN_REQUEST_URL environment variables.

        :stability: experimental
        '''
        result = self._values.get("oidc_request_url")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def oidc_token(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The ID token when authenticating using OpenID Connect (OIDC).

        This can also be sourced from the ARM_OIDC_TOKEN environment variable.

        :stability: experimental
        '''
        result = self._values.get("oidc_token")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def oidc_token_file_path(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The path to a file containing an ID token when authenticating using OpenID Connect (OIDC).

        This can also be sourced from the ARM_OIDC_TOKEN_FILE_PATH environment variable.

        :stability: experimental
        '''
        result = self._values.get("oidc_token_file_path")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def resource_group_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Required) The Name of the Resource Group in which the Storage Account exists.

        :stability: experimental
        '''
        result = self._values.get("resource_group_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sas_token(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The SAS Token used to access the Blob Storage Account.

        This can also be sourced from the ARM_SAS_TOKEN environment variable.

        :stability: experimental
        '''
        result = self._values.get("sas_token")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def snapshot(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Should the Blob used to store the Terraform Statefile be snapshotted before use?

        Defaults to false. This value can also be sourced
        from the ARM_SNAPSHOT environment variable.

        :stability: experimental
        '''
        result = self._values.get("snapshot")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def subscription_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The Subscription ID in which the Storage Account exists.

        This can also be sourced from the ARM_SUBSCRIPTION_ID environment variable.

        :stability: experimental
        '''
        result = self._values.get("subscription_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tenant_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The Tenant ID in which the Subscription exists.

        This can also be sourced from the ARM_TENANT_ID environment variable.

        :stability: experimental
        '''
        result = self._values.get("tenant_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def use_azuread_auth(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Should AzureAD Authentication be used to access the Blob Storage Account.

        This can also be sourced from the ARM_USE_AZUREAD environment
        variable.

        Note: When using AzureAD for Authentication to Storage you also need to
        ensure the Storage Blob Data Owner role is assigned.

        :stability: experimental
        '''
        result = self._values.get("use_azuread_auth")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_microsoft_graph(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Should MSAL be used for authentication instead of ADAL, and should Microsoft Graph be used instead of Azure Active Directory Graph?

        Defaults to true.

        Note: In Terraform 1.2 the Azure Backend uses MSAL (and Microsoft Graph)
        rather than ADAL (and Azure Active Directory Graph) for authentication by
        default - you can disable this by setting use_microsoft_graph to false.
        This setting will be removed in Terraform 1.3, due to Microsoft's
        deprecation of ADAL.

        :stability: experimental
        '''
        result = self._values.get("use_microsoft_graph")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_msi(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Should Managed Service Identity authentication be used?

        This can also be sourced from the ARM_USE_MSI environment variable.

        :stability: experimental
        '''
        result = self._values.get("use_msi")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_oidc(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Should OIDC authentication be used? This can also be sourced from the ARM_USE_OIDC environment variable.

        Note: When using OIDC for authentication, use_microsoft_graph
        must be set to true (which is the default).

        :stability: experimental
        '''
        result = self._values.get("use_oidc")
        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 "DataTerraformRemoteStateAzurermConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class DataTerraformRemoteStateConsul(
    TerraformRemoteState,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.DataTerraformRemoteStateConsul",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        access_token: builtins.str,
        path: builtins.str,
        address: typing.Optional[builtins.str] = None,
        ca_file: typing.Optional[builtins.str] = None,
        cert_file: typing.Optional[builtins.str] = None,
        datacenter: typing.Optional[builtins.str] = None,
        gzip: typing.Optional[builtins.bool] = None,
        http_auth: typing.Optional[builtins.str] = None,
        key_file: typing.Optional[builtins.str] = None,
        lock: typing.Optional[builtins.bool] = None,
        scheme: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param defaults: 
        :param workspace: 
        :param access_token: (experimental) (Required) Access token.
        :param path: (experimental) (Required) Path in the Consul KV store.
        :param address: (experimental) (Optional) DNS name and port of your Consul endpoint specified in the format dnsname:port. Defaults to the local agent HTTP listener.
        :param ca_file: (experimental) (Optional) A path to a PEM-encoded certificate authority used to verify the remote agent's certificate.
        :param cert_file: (experimental) (Optional) A path to a PEM-encoded certificate provided to the remote agent; requires use of key_file.
        :param datacenter: (experimental) (Optional) The datacenter to use. Defaults to that of the agent.
        :param gzip: (experimental) (Optional) true to compress the state data using gzip, or false (the default) to leave it uncompressed.
        :param http_auth: (experimental) (Optional) HTTP Basic Authentication credentials to be used when communicating with Consul, in the format of either user or user:pass.
        :param key_file: (experimental) (Optional) A path to a PEM-encoded private key, required if cert_file is specified.
        :param lock: (experimental) (Optional) false to disable locking. This defaults to true, but will require session permissions with Consul and at least kv write permissions on $path/.lock to perform locking.
        :param scheme: (experimental) (Optional) Specifies what protocol to use when talking to the given address,either http or https. SSL support can also be triggered by setting then environment variable CONSUL_HTTP_SSL to true.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4a2919d5d4b353733457cac7a6ec307201582ddaeed3b88b6ee25afb843eab7d)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = DataTerraformRemoteStateConsulConfig(
            defaults=defaults,
            workspace=workspace,
            access_token=access_token,
            path=path,
            address=address,
            ca_file=ca_file,
            cert_file=cert_file,
            datacenter=datacenter,
            gzip=gzip,
            http_auth=http_auth,
            key_file=key_file,
            lock=lock,
            scheme=scheme,
        )

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


class DataTerraformRemoteStateCos(
    TerraformRemoteState,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.DataTerraformRemoteStateCos",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        bucket: builtins.str,
        accelerate: typing.Optional[builtins.bool] = None,
        acl: typing.Optional[builtins.str] = None,
        assume_role: typing.Optional[typing.Union[CosBackendAssumeRole, typing.Dict[builtins.str, typing.Any]]] = None,
        domain: typing.Optional[builtins.str] = None,
        encrypt: typing.Optional[builtins.bool] = None,
        endpoint: typing.Optional[builtins.str] = None,
        key: typing.Optional[builtins.str] = None,
        prefix: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        secret_id: typing.Optional[builtins.str] = None,
        secret_key: typing.Optional[builtins.str] = None,
        security_token: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param defaults: 
        :param workspace: 
        :param bucket: (experimental) (Required) The name of the COS bucket. You shall manually create it first.
        :param accelerate: (experimental) (Optional) Whether to enable global Acceleration. Defaults to false.
        :param acl: (experimental) (Optional) Object ACL to be applied to the state file, allows private and public-read. Defaults to private.
        :param assume_role: (experimental) (Optional) The assume_role block. If provided, terraform will attempt to assume this role using the supplied credentials.
        :param domain: (experimental) (Optional) The root domain of the API request. Defaults to tencentcloudapi.com. It supports the environment variable TENCENTCLOUD_DOMAIN.
        :param encrypt: (experimental) (Optional) Whether to enable server side encryption of the state file. If it is true, COS will use 'AES256' encryption algorithm to encrypt state file.
        :param endpoint: (experimental) (Optional) The Custom Endpoint for the COS backend. It supports the environment variable TENCENTCLOUD_ENDPOINT.
        :param key: (experimental) (Optional) The path for saving the state file in bucket. Defaults to terraform.tfstate.
        :param prefix: (experimental) (Optional) The directory for saving the state file in bucket. Default to "env:".
        :param region: (experimental) (Optional) The region of the COS bucket. It supports environment variables TENCENTCLOUD_REGION.
        :param secret_id: (experimental) (Optional) Secret id of Tencent Cloud. It supports environment variables TENCENTCLOUD_SECRET_ID.
        :param secret_key: (experimental) (Optional) Secret key of Tencent Cloud. It supports environment variables TENCENTCLOUD_SECRET_KEY.
        :param security_token: (experimental) (Optional) TencentCloud Security Token of temporary access credentials. It supports environment variables TENCENTCLOUD_SECURITY_TOKEN.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7befd4a3968d2c3bb3c5266e7c42ef8867bde80a6a366f391926498bac179949)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = DataTerraformRemoteStateCosConfig(
            defaults=defaults,
            workspace=workspace,
            bucket=bucket,
            accelerate=accelerate,
            acl=acl,
            assume_role=assume_role,
            domain=domain,
            encrypt=encrypt,
            endpoint=endpoint,
            key=key,
            prefix=prefix,
            region=region,
            secret_id=secret_id,
            secret_key=secret_key,
            security_token=security_token,
        )

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


class DataTerraformRemoteStateGcs(
    TerraformRemoteState,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.DataTerraformRemoteStateGcs",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        bucket: builtins.str,
        access_token: typing.Optional[builtins.str] = None,
        credentials: typing.Optional[builtins.str] = None,
        encryption_key: typing.Optional[builtins.str] = None,
        impersonate_service_account: typing.Optional[builtins.str] = None,
        impersonate_service_account_delegates: typing.Optional[typing.Sequence[builtins.str]] = None,
        kms_encryption_key: typing.Optional[builtins.str] = None,
        prefix: typing.Optional[builtins.str] = None,
        storeage_custom_endpoint: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param defaults: 
        :param workspace: 
        :param bucket: (experimental) (Required) The name of the GCS bucket. This name must be globally unique.
        :param access_token: (experimental) (Optional) A temporary [OAuth 2.0 access token] obtained from the Google Authorization server, i.e. the Authorization: Bearer token used to authenticate HTTP requests to GCP APIs. This is an alternative to credentials. If both are specified, access_token will be used over the credentials field.
        :param credentials: (experimental) (Optional) Local path to Google Cloud Platform account credentials in JSON format. If unset, Google Application Default Credentials are used. The provided credentials must have Storage Object Admin role on the bucket. Warning: if using the Google Cloud Platform provider as well, it will also pick up the GOOGLE_CREDENTIALS environment variable.
        :param encryption_key: (experimental) (Optional) A 32 byte base64 encoded 'customer supplied encryption key' used to encrypt all state.
        :param impersonate_service_account: (experimental) (Optional) The service account to impersonate for accessing the State Bucket. You must have roles/iam.serviceAccountTokenCreator role on that account for the impersonation to succeed. If you are using a delegation chain, you can specify that using the impersonate_service_account_delegates field. Alternatively, this can be specified using the GOOGLE_IMPERSONATE_SERVICE_ACCOUNT environment variable.
        :param impersonate_service_account_delegates: (experimental) (Optional) The delegation chain for an impersonating a service account.
        :param kms_encryption_key: (experimental) (Optional) A Cloud KMS key ('customer-managed encryption key') used when reading and writing state files in the bucket. Format should be projects/{{project}}/locations/{{location}}/keyRings/{{keyRing}}/cryptoKeys/{{name}}. For more information, including IAM requirements, see {@link https://cloud.google.com/storage/docs/encryption/customer-managed-keys Customer-managed Encryption Keys}.
        :param prefix: (experimental) (Optional) GCS prefix inside the bucket. Named states for workspaces are stored in an object called /.tfstate.
        :param storeage_custom_endpoint: (experimental) (Optional) A URL containing three parts: the protocol, the DNS name pointing to a Private Service Connect endpoint, and the path for the Cloud Storage API (/storage/v1/b). {@link https://developer.hashicorp.com/terraform/language/settings/backends/gcs#storage_custom_endpoint See here for more details}

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__54b71c4e429ad3f144735cc6763f6c752653379ab351d875822950c26d2fefb6)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = DataTerraformRemoteStateGcsConfig(
            defaults=defaults,
            workspace=workspace,
            bucket=bucket,
            access_token=access_token,
            credentials=credentials,
            encryption_key=encryption_key,
            impersonate_service_account=impersonate_service_account,
            impersonate_service_account_delegates=impersonate_service_account_delegates,
            kms_encryption_key=kms_encryption_key,
            prefix=prefix,
            storeage_custom_endpoint=storeage_custom_endpoint,
        )

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


@jsii.data_type(
    jsii_type="cdktn.DataTerraformRemoteStateGcsConfig",
    jsii_struct_bases=[DataTerraformRemoteStateConfig, GcsBackendConfig],
    name_mapping={
        "defaults": "defaults",
        "workspace": "workspace",
        "bucket": "bucket",
        "access_token": "accessToken",
        "credentials": "credentials",
        "encryption_key": "encryptionKey",
        "impersonate_service_account": "impersonateServiceAccount",
        "impersonate_service_account_delegates": "impersonateServiceAccountDelegates",
        "kms_encryption_key": "kmsEncryptionKey",
        "prefix": "prefix",
        "storeage_custom_endpoint": "storeageCustomEndpoint",
    },
)
class DataTerraformRemoteStateGcsConfig(
    DataTerraformRemoteStateConfig,
    GcsBackendConfig,
):
    def __init__(
        self,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        bucket: builtins.str,
        access_token: typing.Optional[builtins.str] = None,
        credentials: typing.Optional[builtins.str] = None,
        encryption_key: typing.Optional[builtins.str] = None,
        impersonate_service_account: typing.Optional[builtins.str] = None,
        impersonate_service_account_delegates: typing.Optional[typing.Sequence[builtins.str]] = None,
        kms_encryption_key: typing.Optional[builtins.str] = None,
        prefix: typing.Optional[builtins.str] = None,
        storeage_custom_endpoint: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param defaults: 
        :param workspace: 
        :param bucket: (experimental) (Required) The name of the GCS bucket. This name must be globally unique.
        :param access_token: (experimental) (Optional) A temporary [OAuth 2.0 access token] obtained from the Google Authorization server, i.e. the Authorization: Bearer token used to authenticate HTTP requests to GCP APIs. This is an alternative to credentials. If both are specified, access_token will be used over the credentials field.
        :param credentials: (experimental) (Optional) Local path to Google Cloud Platform account credentials in JSON format. If unset, Google Application Default Credentials are used. The provided credentials must have Storage Object Admin role on the bucket. Warning: if using the Google Cloud Platform provider as well, it will also pick up the GOOGLE_CREDENTIALS environment variable.
        :param encryption_key: (experimental) (Optional) A 32 byte base64 encoded 'customer supplied encryption key' used to encrypt all state.
        :param impersonate_service_account: (experimental) (Optional) The service account to impersonate for accessing the State Bucket. You must have roles/iam.serviceAccountTokenCreator role on that account for the impersonation to succeed. If you are using a delegation chain, you can specify that using the impersonate_service_account_delegates field. Alternatively, this can be specified using the GOOGLE_IMPERSONATE_SERVICE_ACCOUNT environment variable.
        :param impersonate_service_account_delegates: (experimental) (Optional) The delegation chain for an impersonating a service account.
        :param kms_encryption_key: (experimental) (Optional) A Cloud KMS key ('customer-managed encryption key') used when reading and writing state files in the bucket. Format should be projects/{{project}}/locations/{{location}}/keyRings/{{keyRing}}/cryptoKeys/{{name}}. For more information, including IAM requirements, see {@link https://cloud.google.com/storage/docs/encryption/customer-managed-keys Customer-managed Encryption Keys}.
        :param prefix: (experimental) (Optional) GCS prefix inside the bucket. Named states for workspaces are stored in an object called /.tfstate.
        :param storeage_custom_endpoint: (experimental) (Optional) A URL containing three parts: the protocol, the DNS name pointing to a Private Service Connect endpoint, and the path for the Cloud Storage API (/storage/v1/b). {@link https://developer.hashicorp.com/terraform/language/settings/backends/gcs#storage_custom_endpoint See here for more details}

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c69baeac37f85edb137a8d5ca2999cf1c01bf6e2a63b14cf60194706808b22e6)
            check_type(argname="argument defaults", value=defaults, expected_type=type_hints["defaults"])
            check_type(argname="argument workspace", value=workspace, expected_type=type_hints["workspace"])
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument access_token", value=access_token, expected_type=type_hints["access_token"])
            check_type(argname="argument credentials", value=credentials, expected_type=type_hints["credentials"])
            check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
            check_type(argname="argument impersonate_service_account", value=impersonate_service_account, expected_type=type_hints["impersonate_service_account"])
            check_type(argname="argument impersonate_service_account_delegates", value=impersonate_service_account_delegates, expected_type=type_hints["impersonate_service_account_delegates"])
            check_type(argname="argument kms_encryption_key", value=kms_encryption_key, expected_type=type_hints["kms_encryption_key"])
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
            check_type(argname="argument storeage_custom_endpoint", value=storeage_custom_endpoint, expected_type=type_hints["storeage_custom_endpoint"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bucket": bucket,
        }
        if defaults is not None:
            self._values["defaults"] = defaults
        if workspace is not None:
            self._values["workspace"] = workspace
        if access_token is not None:
            self._values["access_token"] = access_token
        if credentials is not None:
            self._values["credentials"] = credentials
        if encryption_key is not None:
            self._values["encryption_key"] = encryption_key
        if impersonate_service_account is not None:
            self._values["impersonate_service_account"] = impersonate_service_account
        if impersonate_service_account_delegates is not None:
            self._values["impersonate_service_account_delegates"] = impersonate_service_account_delegates
        if kms_encryption_key is not None:
            self._values["kms_encryption_key"] = kms_encryption_key
        if prefix is not None:
            self._values["prefix"] = prefix
        if storeage_custom_endpoint is not None:
            self._values["storeage_custom_endpoint"] = storeage_custom_endpoint

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

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

    @builtins.property
    def bucket(self) -> builtins.str:
        '''(experimental) (Required) The name of the GCS bucket.

        This name must be globally unique.

        :stability: experimental
        '''
        result = self._values.get("bucket")
        assert result is not None, "Required property 'bucket' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def access_token(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A temporary [OAuth 2.0 access token] obtained from the Google Authorization server, i.e. the Authorization: Bearer token used to authenticate HTTP requests to GCP APIs. This is an alternative to credentials. If both are specified, access_token will be used over the credentials field.

        :stability: experimental
        '''
        result = self._values.get("access_token")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def credentials(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Local path to Google Cloud Platform account credentials in JSON format.

        If unset, Google Application Default Credentials are used.
        The provided credentials must have Storage Object Admin role on the bucket.

        Warning: if using the Google Cloud Platform provider as well,
        it will also pick up the GOOGLE_CREDENTIALS environment variable.

        :stability: experimental
        '''
        result = self._values.get("credentials")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def encryption_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A 32 byte base64 encoded 'customer supplied encryption key' used to encrypt all state.

        :stability: experimental
        '''
        result = self._values.get("encryption_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def impersonate_service_account(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The service account to impersonate for accessing the State Bucket.

        You must have roles/iam.serviceAccountTokenCreator role on that account for the impersonation to succeed.
        If you are using a delegation chain, you can specify that using the impersonate_service_account_delegates field.
        Alternatively, this can be specified using the GOOGLE_IMPERSONATE_SERVICE_ACCOUNT environment variable.

        :stability: experimental
        '''
        result = self._values.get("impersonate_service_account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def impersonate_service_account_delegates(
        self,
    ) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) (Optional) The delegation chain for an impersonating a service account.

        :stability: experimental
        '''
        result = self._values.get("impersonate_service_account_delegates")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def kms_encryption_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A Cloud KMS key ('customer-managed encryption key') used when reading and writing state files in the bucket.

        Format should be projects/{{project}}/locations/{{location}}/keyRings/{{keyRing}}/cryptoKeys/{{name}}.
        For more information, including IAM requirements, see {@link https://cloud.google.com/storage/docs/encryption/customer-managed-keys Customer-managed Encryption Keys}.

        :stability: experimental
        '''
        result = self._values.get("kms_encryption_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def prefix(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) GCS prefix inside the bucket.

        Named states for workspaces are stored in an object called /.tfstate.

        :stability: experimental
        '''
        result = self._values.get("prefix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def storeage_custom_endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A URL containing three parts: the protocol, the DNS name pointing to a Private Service Connect endpoint, and the path for the Cloud Storage API (/storage/v1/b).

        {@link https://developer.hashicorp.com/terraform/language/settings/backends/gcs#storage_custom_endpoint See here for more details}

        :stability: experimental
        '''
        result = self._values.get("storeage_custom_endpoint")
        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 "DataTerraformRemoteStateGcsConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class DataTerraformRemoteStateHttp(
    TerraformRemoteState,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.DataTerraformRemoteStateHttp",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        address: builtins.str,
        client_ca_certificate_pem: typing.Optional[builtins.str] = None,
        client_certificate_pem: typing.Optional[builtins.str] = None,
        client_private_key_pem: typing.Optional[builtins.str] = None,
        lock_address: typing.Optional[builtins.str] = None,
        lock_method: typing.Optional[builtins.str] = None,
        password: typing.Optional[builtins.str] = None,
        retry_max: typing.Optional[jsii.Number] = None,
        retry_wait_max: typing.Optional[jsii.Number] = None,
        retry_wait_min: typing.Optional[jsii.Number] = None,
        skip_cert_verification: typing.Optional[builtins.bool] = None,
        unlock_address: typing.Optional[builtins.str] = None,
        unlock_method: typing.Optional[builtins.str] = None,
        update_method: typing.Optional[builtins.str] = None,
        username: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param defaults: 
        :param workspace: 
        :param address: (experimental) (Required) The address of the REST endpoint.
        :param client_ca_certificate_pem: (experimental) (Optional) A PEM-encoded CA certificate chain used by the client to verify server certificates during TLS authentication.
        :param client_certificate_pem: (experimental) (Optional) A PEM-encoded certificate used by the server to verify the client during mutual TLS (mTLS) authentication.
        :param client_private_key_pem: (experimental) (Optional) A PEM-encoded private key, required if client_certificate_pem is specified.
        :param lock_address: (experimental) (Optional) The address of the lock REST endpoint. Defaults to disabled.
        :param lock_method: (experimental) (Optional) The HTTP method to use when locking. Defaults to LOCK.
        :param password: (experimental) (Optional) The password for HTTP basic authentication.
        :param retry_max: (experimental) (Optional) The number of HTTP request retries. Defaults to 2.
        :param retry_wait_max: (experimental) (Optional) The maximum time in seconds to wait between HTTP request attempts. Defaults to 30.
        :param retry_wait_min: (experimental) (Optional) The minimum time in seconds to wait between HTTP request attempts. Defaults to 1.
        :param skip_cert_verification: (experimental) (Optional) Whether to skip TLS verification. Defaults to false.
        :param unlock_address: (experimental) (Optional) The address of the unlock REST endpoint. Defaults to disabled.
        :param unlock_method: (experimental) (Optional) The HTTP method to use when unlocking. Defaults to UNLOCK.
        :param update_method: (experimental) (Optional) HTTP method to use when updating state. Defaults to POST.
        :param username: (experimental) (Optional) The username for HTTP basic authentication.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0cdf7aff3870beec242c5a780b67285fd9f81a5d44b2663f9b0e2dc8997783f3)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = DataTerraformRemoteStateHttpConfig(
            defaults=defaults,
            workspace=workspace,
            address=address,
            client_ca_certificate_pem=client_ca_certificate_pem,
            client_certificate_pem=client_certificate_pem,
            client_private_key_pem=client_private_key_pem,
            lock_address=lock_address,
            lock_method=lock_method,
            password=password,
            retry_max=retry_max,
            retry_wait_max=retry_wait_max,
            retry_wait_min=retry_wait_min,
            skip_cert_verification=skip_cert_verification,
            unlock_address=unlock_address,
            unlock_method=unlock_method,
            update_method=update_method,
            username=username,
        )

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


@jsii.data_type(
    jsii_type="cdktn.DataTerraformRemoteStateHttpConfig",
    jsii_struct_bases=[DataTerraformRemoteStateConfig, HttpBackendConfig],
    name_mapping={
        "defaults": "defaults",
        "workspace": "workspace",
        "address": "address",
        "client_ca_certificate_pem": "clientCaCertificatePem",
        "client_certificate_pem": "clientCertificatePem",
        "client_private_key_pem": "clientPrivateKeyPem",
        "lock_address": "lockAddress",
        "lock_method": "lockMethod",
        "password": "password",
        "retry_max": "retryMax",
        "retry_wait_max": "retryWaitMax",
        "retry_wait_min": "retryWaitMin",
        "skip_cert_verification": "skipCertVerification",
        "unlock_address": "unlockAddress",
        "unlock_method": "unlockMethod",
        "update_method": "updateMethod",
        "username": "username",
    },
)
class DataTerraformRemoteStateHttpConfig(
    DataTerraformRemoteStateConfig,
    HttpBackendConfig,
):
    def __init__(
        self,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        address: builtins.str,
        client_ca_certificate_pem: typing.Optional[builtins.str] = None,
        client_certificate_pem: typing.Optional[builtins.str] = None,
        client_private_key_pem: typing.Optional[builtins.str] = None,
        lock_address: typing.Optional[builtins.str] = None,
        lock_method: typing.Optional[builtins.str] = None,
        password: typing.Optional[builtins.str] = None,
        retry_max: typing.Optional[jsii.Number] = None,
        retry_wait_max: typing.Optional[jsii.Number] = None,
        retry_wait_min: typing.Optional[jsii.Number] = None,
        skip_cert_verification: typing.Optional[builtins.bool] = None,
        unlock_address: typing.Optional[builtins.str] = None,
        unlock_method: typing.Optional[builtins.str] = None,
        update_method: typing.Optional[builtins.str] = None,
        username: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param defaults: 
        :param workspace: 
        :param address: (experimental) (Required) The address of the REST endpoint.
        :param client_ca_certificate_pem: (experimental) (Optional) A PEM-encoded CA certificate chain used by the client to verify server certificates during TLS authentication.
        :param client_certificate_pem: (experimental) (Optional) A PEM-encoded certificate used by the server to verify the client during mutual TLS (mTLS) authentication.
        :param client_private_key_pem: (experimental) (Optional) A PEM-encoded private key, required if client_certificate_pem is specified.
        :param lock_address: (experimental) (Optional) The address of the lock REST endpoint. Defaults to disabled.
        :param lock_method: (experimental) (Optional) The HTTP method to use when locking. Defaults to LOCK.
        :param password: (experimental) (Optional) The password for HTTP basic authentication.
        :param retry_max: (experimental) (Optional) The number of HTTP request retries. Defaults to 2.
        :param retry_wait_max: (experimental) (Optional) The maximum time in seconds to wait between HTTP request attempts. Defaults to 30.
        :param retry_wait_min: (experimental) (Optional) The minimum time in seconds to wait between HTTP request attempts. Defaults to 1.
        :param skip_cert_verification: (experimental) (Optional) Whether to skip TLS verification. Defaults to false.
        :param unlock_address: (experimental) (Optional) The address of the unlock REST endpoint. Defaults to disabled.
        :param unlock_method: (experimental) (Optional) The HTTP method to use when unlocking. Defaults to UNLOCK.
        :param update_method: (experimental) (Optional) HTTP method to use when updating state. Defaults to POST.
        :param username: (experimental) (Optional) The username for HTTP basic authentication.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__82bd6e4bba7cf98508287662a5c3690d1f4fcb8805ba713fbd5e13d580af9f8c)
            check_type(argname="argument defaults", value=defaults, expected_type=type_hints["defaults"])
            check_type(argname="argument workspace", value=workspace, expected_type=type_hints["workspace"])
            check_type(argname="argument address", value=address, expected_type=type_hints["address"])
            check_type(argname="argument client_ca_certificate_pem", value=client_ca_certificate_pem, expected_type=type_hints["client_ca_certificate_pem"])
            check_type(argname="argument client_certificate_pem", value=client_certificate_pem, expected_type=type_hints["client_certificate_pem"])
            check_type(argname="argument client_private_key_pem", value=client_private_key_pem, expected_type=type_hints["client_private_key_pem"])
            check_type(argname="argument lock_address", value=lock_address, expected_type=type_hints["lock_address"])
            check_type(argname="argument lock_method", value=lock_method, expected_type=type_hints["lock_method"])
            check_type(argname="argument password", value=password, expected_type=type_hints["password"])
            check_type(argname="argument retry_max", value=retry_max, expected_type=type_hints["retry_max"])
            check_type(argname="argument retry_wait_max", value=retry_wait_max, expected_type=type_hints["retry_wait_max"])
            check_type(argname="argument retry_wait_min", value=retry_wait_min, expected_type=type_hints["retry_wait_min"])
            check_type(argname="argument skip_cert_verification", value=skip_cert_verification, expected_type=type_hints["skip_cert_verification"])
            check_type(argname="argument unlock_address", value=unlock_address, expected_type=type_hints["unlock_address"])
            check_type(argname="argument unlock_method", value=unlock_method, expected_type=type_hints["unlock_method"])
            check_type(argname="argument update_method", value=update_method, expected_type=type_hints["update_method"])
            check_type(argname="argument username", value=username, expected_type=type_hints["username"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "address": address,
        }
        if defaults is not None:
            self._values["defaults"] = defaults
        if workspace is not None:
            self._values["workspace"] = workspace
        if client_ca_certificate_pem is not None:
            self._values["client_ca_certificate_pem"] = client_ca_certificate_pem
        if client_certificate_pem is not None:
            self._values["client_certificate_pem"] = client_certificate_pem
        if client_private_key_pem is not None:
            self._values["client_private_key_pem"] = client_private_key_pem
        if lock_address is not None:
            self._values["lock_address"] = lock_address
        if lock_method is not None:
            self._values["lock_method"] = lock_method
        if password is not None:
            self._values["password"] = password
        if retry_max is not None:
            self._values["retry_max"] = retry_max
        if retry_wait_max is not None:
            self._values["retry_wait_max"] = retry_wait_max
        if retry_wait_min is not None:
            self._values["retry_wait_min"] = retry_wait_min
        if skip_cert_verification is not None:
            self._values["skip_cert_verification"] = skip_cert_verification
        if unlock_address is not None:
            self._values["unlock_address"] = unlock_address
        if unlock_method is not None:
            self._values["unlock_method"] = unlock_method
        if update_method is not None:
            self._values["update_method"] = update_method
        if username is not None:
            self._values["username"] = username

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

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

    @builtins.property
    def address(self) -> builtins.str:
        '''(experimental) (Required) The address of the REST endpoint.

        :stability: experimental
        '''
        result = self._values.get("address")
        assert result is not None, "Required property 'address' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def client_ca_certificate_pem(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A PEM-encoded CA certificate chain used by the client to verify server certificates during TLS authentication.

        :stability: experimental
        '''
        result = self._values.get("client_ca_certificate_pem")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def client_certificate_pem(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A PEM-encoded certificate used by the server to verify the client during mutual TLS (mTLS) authentication.

        :stability: experimental
        '''
        result = self._values.get("client_certificate_pem")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def client_private_key_pem(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A PEM-encoded private key, required if client_certificate_pem is specified.

        :stability: experimental
        '''
        result = self._values.get("client_private_key_pem")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def lock_address(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The address of the lock REST endpoint.

        Defaults to disabled.

        :stability: experimental
        '''
        result = self._values.get("lock_address")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def lock_method(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The HTTP method to use when locking.

        Defaults to LOCK.

        :stability: experimental
        '''
        result = self._values.get("lock_method")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def password(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The password for HTTP basic authentication.

        :stability: experimental
        '''
        result = self._values.get("password")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def retry_max(self) -> typing.Optional[jsii.Number]:
        '''(experimental) (Optional) The number of HTTP request retries.

        Defaults to 2.

        :stability: experimental
        '''
        result = self._values.get("retry_max")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def retry_wait_max(self) -> typing.Optional[jsii.Number]:
        '''(experimental) (Optional) The maximum time in seconds to wait between HTTP request attempts.

        Defaults to 30.

        :stability: experimental
        '''
        result = self._values.get("retry_wait_max")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def retry_wait_min(self) -> typing.Optional[jsii.Number]:
        '''(experimental) (Optional) The minimum time in seconds to wait between HTTP request attempts.

        Defaults to 1.

        :stability: experimental
        '''
        result = self._values.get("retry_wait_min")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def skip_cert_verification(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Whether to skip TLS verification.

        Defaults to false.

        :stability: experimental
        '''
        result = self._values.get("skip_cert_verification")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def unlock_address(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The address of the unlock REST endpoint.

        Defaults to disabled.

        :stability: experimental
        '''
        result = self._values.get("unlock_address")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def unlock_method(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The HTTP method to use when unlocking.

        Defaults to UNLOCK.

        :stability: experimental
        '''
        result = self._values.get("unlock_method")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def update_method(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) HTTP method to use when updating state.

        Defaults to POST.

        :stability: experimental
        '''
        result = self._values.get("update_method")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def username(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The username for HTTP basic authentication.

        :stability: experimental
        '''
        result = self._values.get("username")
        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 "DataTerraformRemoteStateHttpConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class DataTerraformRemoteStateLocal(
    TerraformRemoteState,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.DataTerraformRemoteStateLocal",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        path: typing.Optional[builtins.str] = None,
        workspace_dir: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param defaults: 
        :param workspace: 
        :param path: (experimental) Path where the state file is stored. Default: - defaults to terraform.${stackId}.tfstate
        :param workspace_dir: (experimental) (Optional) The path to non-default workspaces.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c572f8e57424eb4b543f2fcf02998c3a0e6d767d6e97a8db79bfb56e52541a18)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = DataTerraformRemoteStateLocalConfig(
            defaults=defaults,
            workspace=workspace,
            path=path,
            workspace_dir=workspace_dir,
        )

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


@jsii.data_type(
    jsii_type="cdktn.DataTerraformRemoteStateLocalConfig",
    jsii_struct_bases=[DataTerraformRemoteStateConfig, LocalBackendConfig],
    name_mapping={
        "defaults": "defaults",
        "workspace": "workspace",
        "path": "path",
        "workspace_dir": "workspaceDir",
    },
)
class DataTerraformRemoteStateLocalConfig(
    DataTerraformRemoteStateConfig,
    LocalBackendConfig,
):
    def __init__(
        self,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        path: typing.Optional[builtins.str] = None,
        workspace_dir: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param defaults: 
        :param workspace: 
        :param path: (experimental) Path where the state file is stored. Default: - defaults to terraform.${stackId}.tfstate
        :param workspace_dir: (experimental) (Optional) The path to non-default workspaces.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__41e7d0b4f0f6e336b16949d937e4e976edffbc253c263d4824fb6a0db3fcfa35)
            check_type(argname="argument defaults", value=defaults, expected_type=type_hints["defaults"])
            check_type(argname="argument workspace", value=workspace, expected_type=type_hints["workspace"])
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
            check_type(argname="argument workspace_dir", value=workspace_dir, expected_type=type_hints["workspace_dir"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if defaults is not None:
            self._values["defaults"] = defaults
        if workspace is not None:
            self._values["workspace"] = workspace
        if path is not None:
            self._values["path"] = path
        if workspace_dir is not None:
            self._values["workspace_dir"] = workspace_dir

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

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

    @builtins.property
    def path(self) -> typing.Optional[builtins.str]:
        '''(experimental) Path where the state file is stored.

        :default: - defaults to terraform.${stackId}.tfstate

        :stability: experimental
        '''
        result = self._values.get("path")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def workspace_dir(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The path to non-default workspaces.

        :stability: experimental
        '''
        result = self._values.get("workspace_dir")
        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 "DataTerraformRemoteStateLocalConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class DataTerraformRemoteStateOss(
    TerraformRemoteState,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.DataTerraformRemoteStateOss",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        bucket: builtins.str,
        access_key: typing.Optional[builtins.str] = None,
        acl: typing.Optional[builtins.str] = None,
        assume_role: typing.Optional[typing.Union[OssAssumeRole, typing.Dict[builtins.str, typing.Any]]] = None,
        assume_role_policy: typing.Optional[builtins.str] = None,
        assume_role_role_arn: typing.Optional[builtins.str] = None,
        assume_role_session_expiration: typing.Optional[jsii.Number] = None,
        assume_role_session_name: typing.Optional[builtins.str] = None,
        ecs_role_name: typing.Optional[builtins.str] = None,
        encrypt: typing.Optional[builtins.bool] = None,
        endpoint: typing.Optional[builtins.str] = None,
        key: typing.Optional[builtins.str] = None,
        prefix: typing.Optional[builtins.str] = None,
        profile: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        secret_key: typing.Optional[builtins.str] = None,
        security_token: typing.Optional[builtins.str] = None,
        shared_credentials_file: typing.Optional[builtins.str] = None,
        sts_endpoint: typing.Optional[builtins.str] = None,
        tablestore_endpoint: typing.Optional[builtins.str] = None,
        tablestore_table: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param defaults: 
        :param workspace: 
        :param bucket: (experimental) (Required) The name of the OSS bucket.
        :param access_key: (experimental) (Optional) Alibaba Cloud access key. It supports environment variables ALICLOUD_ACCESS_KEY and ALICLOUD_ACCESS_KEY_ID.
        :param acl: (experimental) (Optional) Object ACL to be applied to the state file.
        :param assume_role: 
        :param assume_role_policy: (experimental) (Optional, Available in 1.1.0+) A more restrictive policy to apply to the temporary credentials. This gives you a way to further restrict the permissions for the resulting temporary security credentials. You cannot use this policy to grant permissions that exceed those of the role that is being assumed.
        :param assume_role_role_arn: (experimental) (Optional, Available in 1.1.0+) The ARN of the role to assume. If ARN is set to an empty string, it does not perform role switching. It supports the environment variable ALICLOUD_ASSUME_ROLE_ARN. Terraform executes configuration on account with provided credentials.
        :param assume_role_session_expiration: (experimental) (Optional, Available in 1.1.0+) The time after which the established session for assuming role expires. Valid value range: [900-3600] seconds. Default to 3600 (in this case Alibaba Cloud uses its own default value). It supports environment variable ALICLOUD_ASSUME_ROLE_SESSION_EXPIRATION.
        :param assume_role_session_name: (experimental) (Optional, Available in 1.1.0+) The session name to use when assuming the role. If omitted, 'terraform' is passed to the AssumeRole call as session name. It supports environment variable ALICLOUD_ASSUME_ROLE_SESSION_NAME.
        :param ecs_role_name: (experimental) (Optional, Available in 0.12.14+) The RAM Role Name attached on a ECS instance for API operations. You can retrieve this from the 'Access Control' section of the Alibaba Cloud console.
        :param encrypt: (experimental) (Optional) Whether to enable server side encryption of the state file. If it is true, OSS will use 'AES256' encryption algorithm to encrypt state file.
        :param endpoint: (experimental) (Optional) A custom endpoint for the OSS API. It supports environment variables ALICLOUD_OSS_ENDPOINT and OSS_ENDPOINT.
        :param key: (experimental) (Optional) The name of the state file. Defaults to terraform.tfstate.
        :param prefix: (experimental) (Optional) The path directory of the state file will be stored. Default to "env:".
        :param profile: (experimental) (Optional, Available in 0.12.8+) This is the Alibaba Cloud profile name as set in the shared credentials file. It can also be sourced from the ALICLOUD_PROFILE environment variable.
        :param region: (experimental) (Optional) The region of the OSS bucket. It supports environment variables ALICLOUD_REGION and ALICLOUD_DEFAULT_REGION.
        :param secret_key: (experimental) (Optional) Alibaba Cloud secret access key. It supports environment variables ALICLOUD_SECRET_KEY and ALICLOUD_ACCESS_KEY_SECRET.
        :param security_token: (experimental) (Optional) STS access token. It supports environment variable ALICLOUD_SECURITY_TOKEN.
        :param shared_credentials_file: (experimental) (Optional, Available in 0.12.8+) This is the path to the shared credentials file. It can also be sourced from the ALICLOUD_SHARED_CREDENTIALS_FILE environment variable. If this is not set and a profile is specified, ~/.aliyun/config.json will be used.
        :param sts_endpoint: (experimental) (Optional, Available in 1.0.11+) Custom endpoint for the AliCloud Security Token Service (STS) API. It supports environment variable ALICLOUD_STS_ENDPOINT.
        :param tablestore_endpoint: (experimental) (Optional) A custom endpoint for the TableStore API.
        :param tablestore_table: (experimental) (Optional) A TableStore table for state locking and consistency. The table must have a primary key named LockID of type String.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5e0bc032b75ac727fb74f1a9e202198ca7f13c07a6ca91f779cebe83a9a43ee1)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = DataTerraformRemoteStateOssConfig(
            defaults=defaults,
            workspace=workspace,
            bucket=bucket,
            access_key=access_key,
            acl=acl,
            assume_role=assume_role,
            assume_role_policy=assume_role_policy,
            assume_role_role_arn=assume_role_role_arn,
            assume_role_session_expiration=assume_role_session_expiration,
            assume_role_session_name=assume_role_session_name,
            ecs_role_name=ecs_role_name,
            encrypt=encrypt,
            endpoint=endpoint,
            key=key,
            prefix=prefix,
            profile=profile,
            region=region,
            secret_key=secret_key,
            security_token=security_token,
            shared_credentials_file=shared_credentials_file,
            sts_endpoint=sts_endpoint,
            tablestore_endpoint=tablestore_endpoint,
            tablestore_table=tablestore_table,
        )

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


@jsii.data_type(
    jsii_type="cdktn.DataTerraformRemoteStateOssConfig",
    jsii_struct_bases=[DataTerraformRemoteStateConfig, OssBackendConfig],
    name_mapping={
        "defaults": "defaults",
        "workspace": "workspace",
        "bucket": "bucket",
        "access_key": "accessKey",
        "acl": "acl",
        "assume_role": "assumeRole",
        "assume_role_policy": "assumeRolePolicy",
        "assume_role_role_arn": "assumeRoleRoleArn",
        "assume_role_session_expiration": "assumeRoleSessionExpiration",
        "assume_role_session_name": "assumeRoleSessionName",
        "ecs_role_name": "ecsRoleName",
        "encrypt": "encrypt",
        "endpoint": "endpoint",
        "key": "key",
        "prefix": "prefix",
        "profile": "profile",
        "region": "region",
        "secret_key": "secretKey",
        "security_token": "securityToken",
        "shared_credentials_file": "sharedCredentialsFile",
        "sts_endpoint": "stsEndpoint",
        "tablestore_endpoint": "tablestoreEndpoint",
        "tablestore_table": "tablestoreTable",
    },
)
class DataTerraformRemoteStateOssConfig(
    DataTerraformRemoteStateConfig,
    OssBackendConfig,
):
    def __init__(
        self,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        bucket: builtins.str,
        access_key: typing.Optional[builtins.str] = None,
        acl: typing.Optional[builtins.str] = None,
        assume_role: typing.Optional[typing.Union[OssAssumeRole, typing.Dict[builtins.str, typing.Any]]] = None,
        assume_role_policy: typing.Optional[builtins.str] = None,
        assume_role_role_arn: typing.Optional[builtins.str] = None,
        assume_role_session_expiration: typing.Optional[jsii.Number] = None,
        assume_role_session_name: typing.Optional[builtins.str] = None,
        ecs_role_name: typing.Optional[builtins.str] = None,
        encrypt: typing.Optional[builtins.bool] = None,
        endpoint: typing.Optional[builtins.str] = None,
        key: typing.Optional[builtins.str] = None,
        prefix: typing.Optional[builtins.str] = None,
        profile: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        secret_key: typing.Optional[builtins.str] = None,
        security_token: typing.Optional[builtins.str] = None,
        shared_credentials_file: typing.Optional[builtins.str] = None,
        sts_endpoint: typing.Optional[builtins.str] = None,
        tablestore_endpoint: typing.Optional[builtins.str] = None,
        tablestore_table: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param defaults: 
        :param workspace: 
        :param bucket: (experimental) (Required) The name of the OSS bucket.
        :param access_key: (experimental) (Optional) Alibaba Cloud access key. It supports environment variables ALICLOUD_ACCESS_KEY and ALICLOUD_ACCESS_KEY_ID.
        :param acl: (experimental) (Optional) Object ACL to be applied to the state file.
        :param assume_role: 
        :param assume_role_policy: (experimental) (Optional, Available in 1.1.0+) A more restrictive policy to apply to the temporary credentials. This gives you a way to further restrict the permissions for the resulting temporary security credentials. You cannot use this policy to grant permissions that exceed those of the role that is being assumed.
        :param assume_role_role_arn: (experimental) (Optional, Available in 1.1.0+) The ARN of the role to assume. If ARN is set to an empty string, it does not perform role switching. It supports the environment variable ALICLOUD_ASSUME_ROLE_ARN. Terraform executes configuration on account with provided credentials.
        :param assume_role_session_expiration: (experimental) (Optional, Available in 1.1.0+) The time after which the established session for assuming role expires. Valid value range: [900-3600] seconds. Default to 3600 (in this case Alibaba Cloud uses its own default value). It supports environment variable ALICLOUD_ASSUME_ROLE_SESSION_EXPIRATION.
        :param assume_role_session_name: (experimental) (Optional, Available in 1.1.0+) The session name to use when assuming the role. If omitted, 'terraform' is passed to the AssumeRole call as session name. It supports environment variable ALICLOUD_ASSUME_ROLE_SESSION_NAME.
        :param ecs_role_name: (experimental) (Optional, Available in 0.12.14+) The RAM Role Name attached on a ECS instance for API operations. You can retrieve this from the 'Access Control' section of the Alibaba Cloud console.
        :param encrypt: (experimental) (Optional) Whether to enable server side encryption of the state file. If it is true, OSS will use 'AES256' encryption algorithm to encrypt state file.
        :param endpoint: (experimental) (Optional) A custom endpoint for the OSS API. It supports environment variables ALICLOUD_OSS_ENDPOINT and OSS_ENDPOINT.
        :param key: (experimental) (Optional) The name of the state file. Defaults to terraform.tfstate.
        :param prefix: (experimental) (Optional) The path directory of the state file will be stored. Default to "env:".
        :param profile: (experimental) (Optional, Available in 0.12.8+) This is the Alibaba Cloud profile name as set in the shared credentials file. It can also be sourced from the ALICLOUD_PROFILE environment variable.
        :param region: (experimental) (Optional) The region of the OSS bucket. It supports environment variables ALICLOUD_REGION and ALICLOUD_DEFAULT_REGION.
        :param secret_key: (experimental) (Optional) Alibaba Cloud secret access key. It supports environment variables ALICLOUD_SECRET_KEY and ALICLOUD_ACCESS_KEY_SECRET.
        :param security_token: (experimental) (Optional) STS access token. It supports environment variable ALICLOUD_SECURITY_TOKEN.
        :param shared_credentials_file: (experimental) (Optional, Available in 0.12.8+) This is the path to the shared credentials file. It can also be sourced from the ALICLOUD_SHARED_CREDENTIALS_FILE environment variable. If this is not set and a profile is specified, ~/.aliyun/config.json will be used.
        :param sts_endpoint: (experimental) (Optional, Available in 1.0.11+) Custom endpoint for the AliCloud Security Token Service (STS) API. It supports environment variable ALICLOUD_STS_ENDPOINT.
        :param tablestore_endpoint: (experimental) (Optional) A custom endpoint for the TableStore API.
        :param tablestore_table: (experimental) (Optional) A TableStore table for state locking and consistency. The table must have a primary key named LockID of type String.

        :stability: experimental
        '''
        if isinstance(assume_role, dict):
            assume_role = OssAssumeRole(**assume_role)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e9ffb7d920480b404e1906d0f3f146a90dc8f5a0d08d2f47e4daa1723eb2e6ef)
            check_type(argname="argument defaults", value=defaults, expected_type=type_hints["defaults"])
            check_type(argname="argument workspace", value=workspace, expected_type=type_hints["workspace"])
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument access_key", value=access_key, expected_type=type_hints["access_key"])
            check_type(argname="argument acl", value=acl, expected_type=type_hints["acl"])
            check_type(argname="argument assume_role", value=assume_role, expected_type=type_hints["assume_role"])
            check_type(argname="argument assume_role_policy", value=assume_role_policy, expected_type=type_hints["assume_role_policy"])
            check_type(argname="argument assume_role_role_arn", value=assume_role_role_arn, expected_type=type_hints["assume_role_role_arn"])
            check_type(argname="argument assume_role_session_expiration", value=assume_role_session_expiration, expected_type=type_hints["assume_role_session_expiration"])
            check_type(argname="argument assume_role_session_name", value=assume_role_session_name, expected_type=type_hints["assume_role_session_name"])
            check_type(argname="argument ecs_role_name", value=ecs_role_name, expected_type=type_hints["ecs_role_name"])
            check_type(argname="argument encrypt", value=encrypt, expected_type=type_hints["encrypt"])
            check_type(argname="argument endpoint", value=endpoint, expected_type=type_hints["endpoint"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
            check_type(argname="argument profile", value=profile, expected_type=type_hints["profile"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument secret_key", value=secret_key, expected_type=type_hints["secret_key"])
            check_type(argname="argument security_token", value=security_token, expected_type=type_hints["security_token"])
            check_type(argname="argument shared_credentials_file", value=shared_credentials_file, expected_type=type_hints["shared_credentials_file"])
            check_type(argname="argument sts_endpoint", value=sts_endpoint, expected_type=type_hints["sts_endpoint"])
            check_type(argname="argument tablestore_endpoint", value=tablestore_endpoint, expected_type=type_hints["tablestore_endpoint"])
            check_type(argname="argument tablestore_table", value=tablestore_table, expected_type=type_hints["tablestore_table"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bucket": bucket,
        }
        if defaults is not None:
            self._values["defaults"] = defaults
        if workspace is not None:
            self._values["workspace"] = workspace
        if access_key is not None:
            self._values["access_key"] = access_key
        if acl is not None:
            self._values["acl"] = acl
        if assume_role is not None:
            self._values["assume_role"] = assume_role
        if assume_role_policy is not None:
            self._values["assume_role_policy"] = assume_role_policy
        if assume_role_role_arn is not None:
            self._values["assume_role_role_arn"] = assume_role_role_arn
        if assume_role_session_expiration is not None:
            self._values["assume_role_session_expiration"] = assume_role_session_expiration
        if assume_role_session_name is not None:
            self._values["assume_role_session_name"] = assume_role_session_name
        if ecs_role_name is not None:
            self._values["ecs_role_name"] = ecs_role_name
        if encrypt is not None:
            self._values["encrypt"] = encrypt
        if endpoint is not None:
            self._values["endpoint"] = endpoint
        if key is not None:
            self._values["key"] = key
        if prefix is not None:
            self._values["prefix"] = prefix
        if profile is not None:
            self._values["profile"] = profile
        if region is not None:
            self._values["region"] = region
        if secret_key is not None:
            self._values["secret_key"] = secret_key
        if security_token is not None:
            self._values["security_token"] = security_token
        if shared_credentials_file is not None:
            self._values["shared_credentials_file"] = shared_credentials_file
        if sts_endpoint is not None:
            self._values["sts_endpoint"] = sts_endpoint
        if tablestore_endpoint is not None:
            self._values["tablestore_endpoint"] = tablestore_endpoint
        if tablestore_table is not None:
            self._values["tablestore_table"] = tablestore_table

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

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

    @builtins.property
    def bucket(self) -> builtins.str:
        '''(experimental) (Required) The name of the OSS bucket.

        :stability: experimental
        '''
        result = self._values.get("bucket")
        assert result is not None, "Required property 'bucket' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def access_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Alibaba Cloud access key.

        It supports environment variables ALICLOUD_ACCESS_KEY and ALICLOUD_ACCESS_KEY_ID.

        :stability: experimental
        '''
        result = self._values.get("access_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def acl(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Object ACL to be applied to the state file.

        :stability: experimental
        '''
        result = self._values.get("acl")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def assume_role(self) -> typing.Optional[OssAssumeRole]:
        '''
        :deprecated: Use flattened assume role options

        :stability: deprecated
        '''
        result = self._values.get("assume_role")
        return typing.cast(typing.Optional[OssAssumeRole], result)

    @builtins.property
    def assume_role_policy(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional, Available in 1.1.0+) A more restrictive policy to apply to the temporary credentials. This gives you a way to further restrict the permissions for the resulting temporary security credentials. You cannot use this policy to grant permissions that exceed those of the role that is being assumed.

        :stability: experimental
        '''
        result = self._values.get("assume_role_policy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def assume_role_role_arn(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional, Available in 1.1.0+) The ARN of the role to assume. If ARN is set to an empty string, it does not perform role switching. It supports the environment variable ALICLOUD_ASSUME_ROLE_ARN. Terraform executes configuration on account with provided credentials.

        :stability: experimental
        '''
        result = self._values.get("assume_role_role_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def assume_role_session_expiration(self) -> typing.Optional[jsii.Number]:
        '''(experimental) (Optional, Available in 1.1.0+) The time after which the established session for assuming role expires. Valid value range: [900-3600] seconds. Default to 3600 (in this case Alibaba Cloud uses its own default value). It supports environment variable ALICLOUD_ASSUME_ROLE_SESSION_EXPIRATION.

        :stability: experimental
        '''
        result = self._values.get("assume_role_session_expiration")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def assume_role_session_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional, Available in 1.1.0+) The session name to use when assuming the role. If omitted, 'terraform' is passed to the AssumeRole call as session name. It supports environment variable ALICLOUD_ASSUME_ROLE_SESSION_NAME.

        :stability: experimental
        '''
        result = self._values.get("assume_role_session_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ecs_role_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional, Available in 0.12.14+) The RAM Role Name attached on a ECS instance for API operations. You can retrieve this from the 'Access Control' section of the Alibaba Cloud console.

        :stability: experimental
        '''
        result = self._values.get("ecs_role_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def encrypt(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Whether to enable server side encryption of the state file.

        If it is true, OSS will use 'AES256' encryption algorithm to encrypt state file.

        :stability: experimental
        '''
        result = self._values.get("encrypt")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A custom endpoint for the OSS API.

        It supports environment variables ALICLOUD_OSS_ENDPOINT and OSS_ENDPOINT.

        :stability: experimental
        '''
        result = self._values.get("endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The name of the state file.

        Defaults to terraform.tfstate.

        :stability: experimental
        '''
        result = self._values.get("key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def prefix(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The path directory of the state file will be stored.

        Default to "env:".

        :stability: experimental
        '''
        result = self._values.get("prefix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def profile(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional, Available in 0.12.8+) This is the Alibaba Cloud profile name as set in the shared credentials file. It can also be sourced from the ALICLOUD_PROFILE environment variable.

        :stability: experimental
        '''
        result = self._values.get("profile")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The region of the OSS bucket.

        It supports environment variables ALICLOUD_REGION and ALICLOUD_DEFAULT_REGION.

        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def secret_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Alibaba Cloud secret access key.

        It supports environment variables ALICLOUD_SECRET_KEY and ALICLOUD_ACCESS_KEY_SECRET.

        :stability: experimental
        '''
        result = self._values.get("secret_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def security_token(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) STS access token.

        It supports environment variable ALICLOUD_SECURITY_TOKEN.

        :stability: experimental
        '''
        result = self._values.get("security_token")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def shared_credentials_file(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional, Available in 0.12.8+) This is the path to the shared credentials file. It can also be sourced from the ALICLOUD_SHARED_CREDENTIALS_FILE environment variable. If this is not set and a profile is specified, ~/.aliyun/config.json will be used.

        :stability: experimental
        '''
        result = self._values.get("shared_credentials_file")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sts_endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional, Available in 1.0.11+) Custom endpoint for the AliCloud Security Token Service (STS) API. It supports environment variable ALICLOUD_STS_ENDPOINT.

        :stability: experimental
        '''
        result = self._values.get("sts_endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tablestore_endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A custom endpoint for the TableStore API.

        :stability: experimental
        '''
        result = self._values.get("tablestore_endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tablestore_table(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) A TableStore table for state locking and consistency.

        The table must have a primary key named LockID of type String.

        :stability: experimental
        '''
        result = self._values.get("tablestore_table")
        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 "DataTerraformRemoteStateOssConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class DataTerraformRemoteStatePg(
    TerraformRemoteState,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.DataTerraformRemoteStatePg",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        conn_str: builtins.str,
        schema_name: typing.Optional[builtins.str] = None,
        skip_index_creation: typing.Optional[builtins.bool] = None,
        skip_schema_creation: typing.Optional[builtins.bool] = None,
        skip_table_creation: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param defaults: 
        :param workspace: 
        :param conn_str: (experimental) Postgres connection string; a postgres:// URL. The PG_CONN_STR and standard libpq environment variables can also be used to indicate how to connect to the PostgreSQL database.
        :param schema_name: (experimental) Name of the automatically-managed Postgres schema, default to terraform_remote_state. Can also be set using the PG_SCHEMA_NAME environment variable.
        :param skip_index_creation: (experimental) If set to true, the Postgres index must already exist. Can also be set using the PG_SKIP_INDEX_CREATION environment variable. Terraform won't try to create the index, this is useful when it has already been created by a database administrator.
        :param skip_schema_creation: (experimental) If set to true, the Postgres schema must already exist. Can also be set using the PG_SKIP_SCHEMA_CREATION environment variable. Terraform won't try to create the schema, this is useful when it has already been created by a database administrator.
        :param skip_table_creation: (experimental) If set to true, the Postgres table must already exist. Can also be set using the PG_SKIP_TABLE_CREATION environment variable. Terraform won't try to create the table, this is useful when it has already been created by a database administrator.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a03e4edfed23b03162d1ff8b05944a64b3c8755f4397d4994cfdd8f3828e8787)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = DataTerraformRemoteStatePgConfig(
            defaults=defaults,
            workspace=workspace,
            conn_str=conn_str,
            schema_name=schema_name,
            skip_index_creation=skip_index_creation,
            skip_schema_creation=skip_schema_creation,
            skip_table_creation=skip_table_creation,
        )

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


@jsii.data_type(
    jsii_type="cdktn.DataTerraformRemoteStatePgConfig",
    jsii_struct_bases=[DataTerraformRemoteStateConfig, PgBackendConfig],
    name_mapping={
        "defaults": "defaults",
        "workspace": "workspace",
        "conn_str": "connStr",
        "schema_name": "schemaName",
        "skip_index_creation": "skipIndexCreation",
        "skip_schema_creation": "skipSchemaCreation",
        "skip_table_creation": "skipTableCreation",
    },
)
class DataTerraformRemoteStatePgConfig(DataTerraformRemoteStateConfig, PgBackendConfig):
    def __init__(
        self,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        conn_str: builtins.str,
        schema_name: typing.Optional[builtins.str] = None,
        skip_index_creation: typing.Optional[builtins.bool] = None,
        skip_schema_creation: typing.Optional[builtins.bool] = None,
        skip_table_creation: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param defaults: 
        :param workspace: 
        :param conn_str: (experimental) Postgres connection string; a postgres:// URL. The PG_CONN_STR and standard libpq environment variables can also be used to indicate how to connect to the PostgreSQL database.
        :param schema_name: (experimental) Name of the automatically-managed Postgres schema, default to terraform_remote_state. Can also be set using the PG_SCHEMA_NAME environment variable.
        :param skip_index_creation: (experimental) If set to true, the Postgres index must already exist. Can also be set using the PG_SKIP_INDEX_CREATION environment variable. Terraform won't try to create the index, this is useful when it has already been created by a database administrator.
        :param skip_schema_creation: (experimental) If set to true, the Postgres schema must already exist. Can also be set using the PG_SKIP_SCHEMA_CREATION environment variable. Terraform won't try to create the schema, this is useful when it has already been created by a database administrator.
        :param skip_table_creation: (experimental) If set to true, the Postgres table must already exist. Can also be set using the PG_SKIP_TABLE_CREATION environment variable. Terraform won't try to create the table, this is useful when it has already been created by a database administrator.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__576a0e230ad4aaa9d88be8e4e8b10641aaf3e690f7ea44d6feda09df386f4256)
            check_type(argname="argument defaults", value=defaults, expected_type=type_hints["defaults"])
            check_type(argname="argument workspace", value=workspace, expected_type=type_hints["workspace"])
            check_type(argname="argument conn_str", value=conn_str, expected_type=type_hints["conn_str"])
            check_type(argname="argument schema_name", value=schema_name, expected_type=type_hints["schema_name"])
            check_type(argname="argument skip_index_creation", value=skip_index_creation, expected_type=type_hints["skip_index_creation"])
            check_type(argname="argument skip_schema_creation", value=skip_schema_creation, expected_type=type_hints["skip_schema_creation"])
            check_type(argname="argument skip_table_creation", value=skip_table_creation, expected_type=type_hints["skip_table_creation"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "conn_str": conn_str,
        }
        if defaults is not None:
            self._values["defaults"] = defaults
        if workspace is not None:
            self._values["workspace"] = workspace
        if schema_name is not None:
            self._values["schema_name"] = schema_name
        if skip_index_creation is not None:
            self._values["skip_index_creation"] = skip_index_creation
        if skip_schema_creation is not None:
            self._values["skip_schema_creation"] = skip_schema_creation
        if skip_table_creation is not None:
            self._values["skip_table_creation"] = skip_table_creation

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

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

    @builtins.property
    def conn_str(self) -> builtins.str:
        '''(experimental) Postgres connection string;

        a postgres:// URL.
        The PG_CONN_STR and standard libpq environment variables can also be used to indicate how to connect to the PostgreSQL database.

        :stability: experimental
        '''
        result = self._values.get("conn_str")
        assert result is not None, "Required property 'conn_str' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def schema_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Name of the automatically-managed Postgres schema, default to terraform_remote_state.

        Can also be set using the PG_SCHEMA_NAME environment variable.

        :stability: experimental
        '''
        result = self._values.get("schema_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def skip_index_creation(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If set to true, the Postgres index must already exist.

        Can also be set using the PG_SKIP_INDEX_CREATION environment variable.
        Terraform won't try to create the index, this is useful when it has already been created by a database administrator.

        :stability: experimental
        '''
        result = self._values.get("skip_index_creation")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def skip_schema_creation(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If set to true, the Postgres schema must already exist.

        Can also be set using the PG_SKIP_SCHEMA_CREATION environment variable.
        Terraform won't try to create the schema, this is useful when it has already been created by a database administrator.

        :stability: experimental
        '''
        result = self._values.get("skip_schema_creation")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def skip_table_creation(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If set to true, the Postgres table must already exist.

        Can also be set using the PG_SKIP_TABLE_CREATION environment variable.
        Terraform won't try to create the table, this is useful when it has already been created by a database administrator.

        :stability: experimental
        '''
        result = self._values.get("skip_table_creation")
        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 "DataTerraformRemoteStatePgConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.DataTerraformRemoteStateRemoteConfig",
    jsii_struct_bases=[DataTerraformRemoteStateConfig, RemoteBackendConfig],
    name_mapping={
        "defaults": "defaults",
        "workspace": "workspace",
        "organization": "organization",
        "workspaces": "workspaces",
        "hostname": "hostname",
        "token": "token",
    },
)
class DataTerraformRemoteStateRemoteConfig(
    DataTerraformRemoteStateConfig,
    RemoteBackendConfig,
):
    def __init__(
        self,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        organization: builtins.str,
        workspaces: IRemoteWorkspace,
        hostname: typing.Optional[builtins.str] = None,
        token: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param defaults: 
        :param workspace: 
        :param organization: 
        :param workspaces: 
        :param hostname: 
        :param token: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9d4dd626119f3592cae0f08752c34d8cb02cc416fba3e72bf476fdb3d69040fc)
            check_type(argname="argument defaults", value=defaults, expected_type=type_hints["defaults"])
            check_type(argname="argument workspace", value=workspace, expected_type=type_hints["workspace"])
            check_type(argname="argument organization", value=organization, expected_type=type_hints["organization"])
            check_type(argname="argument workspaces", value=workspaces, expected_type=type_hints["workspaces"])
            check_type(argname="argument hostname", value=hostname, expected_type=type_hints["hostname"])
            check_type(argname="argument token", value=token, expected_type=type_hints["token"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "organization": organization,
            "workspaces": workspaces,
        }
        if defaults is not None:
            self._values["defaults"] = defaults
        if workspace is not None:
            self._values["workspace"] = workspace
        if hostname is not None:
            self._values["hostname"] = hostname
        if token is not None:
            self._values["token"] = token

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

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

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

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

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

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


class DataTerraformRemoteStateS3(
    TerraformRemoteState,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.DataTerraformRemoteStateS3",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        bucket: builtins.str,
        key: builtins.str,
        access_key: typing.Optional[builtins.str] = None,
        acl: typing.Optional[builtins.str] = None,
        allowed_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        assume_role: typing.Optional[typing.Union[S3BackendAssumeRoleConfig, typing.Dict[builtins.str, typing.Any]]] = None,
        assume_role_policy: typing.Optional[builtins.str] = None,
        assume_role_policy_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
        assume_role_tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        assume_role_transitive_tag_keys: typing.Optional[typing.Sequence[builtins.str]] = None,
        assume_role_with_web_identity: typing.Optional[typing.Union[S3BackendAssumeRoleWithWebIdentityConfig, typing.Dict[builtins.str, typing.Any]]] = None,
        custom_ca_bundle: typing.Optional[builtins.str] = None,
        dynamodb_endpoint: typing.Optional[builtins.str] = None,
        dynamodb_table: typing.Optional[builtins.str] = None,
        ec2_metadata_service_endpoint: typing.Optional[builtins.str] = None,
        ec2_metadata_service_endpoint_mode: typing.Optional[builtins.str] = None,
        encrypt: typing.Optional[builtins.bool] = None,
        endpoint: typing.Optional[builtins.str] = None,
        endpoints: typing.Optional[typing.Union[S3BackendEndpointConfig, typing.Dict[builtins.str, typing.Any]]] = None,
        external_id: typing.Optional[builtins.str] = None,
        forbidden_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        force_path_style: typing.Optional[builtins.bool] = None,
        http_proxy: typing.Optional[builtins.str] = None,
        https_proxy: typing.Optional[builtins.str] = None,
        iam_endpoint: typing.Optional[builtins.str] = None,
        insecure: typing.Optional[builtins.bool] = None,
        kms_key_id: typing.Optional[builtins.str] = None,
        max_retries: typing.Optional[jsii.Number] = None,
        no_proxy: typing.Optional[builtins.str] = None,
        profile: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        retry_mode: typing.Optional[builtins.str] = None,
        role_arn: typing.Optional[builtins.str] = None,
        secret_key: typing.Optional[builtins.str] = None,
        session_name: typing.Optional[builtins.str] = None,
        shared_config_files: typing.Optional[typing.Sequence[builtins.str]] = None,
        shared_credentials_file: typing.Optional[builtins.str] = None,
        shared_credentials_files: typing.Optional[typing.Sequence[builtins.str]] = None,
        skip_credentials_validation: typing.Optional[builtins.bool] = None,
        skip_metadata_api_check: typing.Optional[builtins.bool] = None,
        skip_region_validation: typing.Optional[builtins.bool] = None,
        skip_requesting_account_id: typing.Optional[builtins.bool] = None,
        skip_s3_checksum: typing.Optional[builtins.bool] = None,
        sse_customer_key: typing.Optional[builtins.str] = None,
        sts_endpoint: typing.Optional[builtins.str] = None,
        sts_region: typing.Optional[builtins.str] = None,
        token: typing.Optional[builtins.str] = None,
        use_legacy_workflow: typing.Optional[builtins.bool] = None,
        use_path_style: typing.Optional[builtins.bool] = None,
        workspace_key_prefix: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param defaults: 
        :param workspace: 
        :param bucket: (experimental) Name of the S3 Bucket.
        :param key: (experimental) Path to the state file inside the S3 Bucket. When using a non-default workspace, the state path will be /workspace_key_prefix/workspace_name/key
        :param access_key: (experimental) (Optional) AWS access key. If configured, must also configure secret_key. This can also be sourced from the AWS_ACCESS_KEY_ID environment variable, AWS shared credentials file (e.g. ~/.aws/credentials), or AWS shared configuration file (e.g. ~/.aws/config).
        :param acl: (experimental) (Optional) Canned ACL to be applied to the state file.
        :param allowed_account_ids: (experimental) (Optional) List of allowed AWS account IDs to prevent potential destruction of a live environment. Conflicts with forbidden_account_ids.
        :param assume_role: (experimental) Assuming an IAM Role can be configured in two ways. The preferred way is to use the argument assume_role, the other, which is deprecated, is with arguments at the top level.
        :param assume_role_policy: (deprecated) (Optional) IAM Policy JSON describing further restricting permissions for the IAM Role being assumed.
        :param assume_role_policy_arns: (deprecated) (Optional) Set of Amazon Resource Names (ARNs) of IAM Policies describing further restricting permissions for the IAM Role being assumed.
        :param assume_role_tags: (deprecated) (Optional) Map of assume role session tags.
        :param assume_role_transitive_tag_keys: (deprecated) (Optional) Set of assume role session tag keys to pass to any subsequent sessions.
        :param assume_role_with_web_identity: (experimental) Assume Role With Web Identity Configuration.
        :param custom_ca_bundle: (experimental) (Optional) File containing custom root and intermediate certificates. Can also be set using the AWS_CA_BUNDLE environment variable. Setting ca_bundle in the shared config file is not supported.
        :param dynamodb_endpoint: (deprecated) (Optional) Custom endpoint for the AWS DynamoDB API. This can also be sourced from the AWS_DYNAMODB_ENDPOINT environment variable.
        :param dynamodb_table: (experimental) (Optional) Name of DynamoDB Table to use for state locking and consistency. The table must have a partition key named LockID with type of String. If not configured, state locking will be disabled.
        :param ec2_metadata_service_endpoint: (experimental) Optional) Custom endpoint URL for the EC2 Instance Metadata Service (IMDS) API. Can also be set with the AWS_EC2_METADATA_SERVICE_ENDPOINT environment variable.
        :param ec2_metadata_service_endpoint_mode: (experimental) (Optional) Mode to use in communicating with the metadata service. Valid values are IPv4 and IPv6. Can also be set with the AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE environment variable.
        :param encrypt: (experimental) (Optional) Enable server side encryption of the state file.
        :param endpoint: (deprecated) (Optional) Custom endpoint for the AWS S3 API. This can also be sourced from the AWS_S3_ENDPOINT environment variable.
        :param endpoints: (experimental) (Optional) The endpoint configuration block.
        :param external_id: (deprecated) (Optional) External identifier to use when assuming the role.
        :param forbidden_account_ids: (experimental) (Optional) List of forbidden AWS account IDs to prevent potential destruction of a live environment. Conflicts with allowed_account_ids.
        :param force_path_style: (deprecated) (Optional) Enable path-style S3 URLs (https:/// instead of https://.).
        :param http_proxy: (experimental) (Optional) URL of a proxy to use for HTTP requests when accessing the AWS API. Can also be set using the HTTP_PROXY or http_proxy environment variables.
        :param https_proxy: (experimental) (Optional) URL of a proxy to use for HTTPS requests when accessing the AWS API. Can also be set using the HTTPS_PROXY or https_proxy environment variables.
        :param iam_endpoint: (deprecated) (Optional) Custom endpoint for the AWS Identity and Access Management (IAM) API. This can also be sourced from the AWS_IAM_ENDPOINT environment variable.
        :param insecure: (experimental) Optional) Whether to explicitly allow the backend to perform "insecure" SSL requests. If omitted, the default value is false.
        :param kms_key_id: (experimental) (Optional) Amazon Resource Name (ARN) of a Key Management Service (KMS) Key to use for encrypting the state. Note that if this value is specified, Terraform will need kms:Encrypt, kms:Decrypt and kms:GenerateDataKey permissions on this KMS key.
        :param max_retries: (experimental) (Optional) The maximum number of times an AWS API request is retried on retryable failure. Defaults to 5.
        :param no_proxy: (experimental) (Optional) Comma-separated list of hosts that should not use HTTP or HTTPS proxies. Each value can be one of: - A domain name - An IP address - A CIDR address - An asterisk (*), to indicate that no proxying should be performed Domain name and IP address values can also include a port number. Can also be set using the NO_PROXY or no_proxy environment variables.
        :param profile: (experimental) (Optional) Name of AWS profile in AWS shared credentials file (e.g. ~/.aws/credentials) or AWS shared configuration file (e.g. ~/.aws/config) to use for credentials and/or configuration. This can also be sourced from the AWS_PROFILE environment variable.
        :param region: (experimental) AWS Region of the S3 Bucket and DynamoDB Table (if used). This can also be sourced from the AWS_DEFAULT_REGION and AWS_REGION environment variables.
        :param retry_mode: (experimental) (Optional) Specifies how retries are attempted. Valid values are standard and adaptive. Can also be configured using the AWS_RETRY_MODE environment variable or the shared config file parameter retry_mode.
        :param role_arn: (deprecated) (Optional) Amazon Resource Name (ARN) of the IAM Role to assume.
        :param secret_key: (experimental) (Optional) AWS secret access key. If configured, must also configure access_key. This can also be sourced from the AWS_SECRET_ACCESS_KEY environment variable, AWS shared credentials file (e.g. ~/.aws/credentials), or AWS shared configuration file (e.g. ~/.aws/config)
        :param session_name: (deprecated) (Optional) Session name to use when assuming the role.
        :param shared_config_files: (experimental) (Optional) List of paths to AWS shared configuration files. Defaults to ~/.aws/config.
        :param shared_credentials_file: (experimental) (Optional) Path to the AWS shared credentials file. Defaults to ~/.aws/credentials.
        :param shared_credentials_files: (experimental) (Optional) List of paths to AWS shared credentials files. Defaults to ~/.aws/credentials.
        :param skip_credentials_validation: (experimental) (Optional) Skip credentials validation via the STS API.
        :param skip_metadata_api_check: (experimental) (Optional) Skip usage of EC2 Metadata API.
        :param skip_region_validation: (experimental) (Optional) Skip validation of provided region name.
        :param skip_requesting_account_id: (experimental) (Optional) Whether to skip requesting the account ID. Useful for AWS API implementations that do not have the IAM, STS API, or metadata API.
        :param skip_s3_checksum: (experimental) (Optional) Do not include checksum when uploading S3 Objects. Useful for some S3-Compatible APIs.
        :param sse_customer_key: (experimental) (Optional) The key to use for encrypting state with Server-Side Encryption with Customer-Provided Keys (SSE-C). This is the base64-encoded value of the key, which must decode to 256 bits. This can also be sourced from the AWS_SSE_CUSTOMER_KEY environment variable, which is recommended due to the sensitivity of the value. Setting it inside a terraform file will cause it to be persisted to disk in terraform.tfstate.
        :param sts_endpoint: (deprecated) (Optional) Custom endpoint for the AWS Security Token Service (STS) API. This can also be sourced from the AWS_STS_ENDPOINT environment variable.
        :param sts_region: (experimental) (Optional) AWS region for STS. If unset, AWS will use the same region for STS as other non-STS operations.
        :param token: (experimental) (Optional) Multi-Factor Authentication (MFA) token. This can also be sourced from the AWS_SESSION_TOKEN environment variable.
        :param use_legacy_workflow: (experimental) (Optional) Use the legacy authentication workflow, preferring environment variables over backend configuration. Defaults to true. This behavior does not align with the authentication flow of the AWS CLI or SDK's, and will be removed in the future.
        :param use_path_style: (experimental) (Optional) Enable path-style S3 URLs (https:/// instead of https://.).
        :param workspace_key_prefix: (experimental) (Optional) Prefix applied to the state path inside the bucket. This is only relevant when using a non-default workspace. Defaults to env:

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e2e03d6f3d69e37add63c033321c1e0024b24fd2b0cc457cea463794befdbb7b)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = DataTerraformRemoteStateS3Config(
            defaults=defaults,
            workspace=workspace,
            bucket=bucket,
            key=key,
            access_key=access_key,
            acl=acl,
            allowed_account_ids=allowed_account_ids,
            assume_role=assume_role,
            assume_role_policy=assume_role_policy,
            assume_role_policy_arns=assume_role_policy_arns,
            assume_role_tags=assume_role_tags,
            assume_role_transitive_tag_keys=assume_role_transitive_tag_keys,
            assume_role_with_web_identity=assume_role_with_web_identity,
            custom_ca_bundle=custom_ca_bundle,
            dynamodb_endpoint=dynamodb_endpoint,
            dynamodb_table=dynamodb_table,
            ec2_metadata_service_endpoint=ec2_metadata_service_endpoint,
            ec2_metadata_service_endpoint_mode=ec2_metadata_service_endpoint_mode,
            encrypt=encrypt,
            endpoint=endpoint,
            endpoints=endpoints,
            external_id=external_id,
            forbidden_account_ids=forbidden_account_ids,
            force_path_style=force_path_style,
            http_proxy=http_proxy,
            https_proxy=https_proxy,
            iam_endpoint=iam_endpoint,
            insecure=insecure,
            kms_key_id=kms_key_id,
            max_retries=max_retries,
            no_proxy=no_proxy,
            profile=profile,
            region=region,
            retry_mode=retry_mode,
            role_arn=role_arn,
            secret_key=secret_key,
            session_name=session_name,
            shared_config_files=shared_config_files,
            shared_credentials_file=shared_credentials_file,
            shared_credentials_files=shared_credentials_files,
            skip_credentials_validation=skip_credentials_validation,
            skip_metadata_api_check=skip_metadata_api_check,
            skip_region_validation=skip_region_validation,
            skip_requesting_account_id=skip_requesting_account_id,
            skip_s3_checksum=skip_s3_checksum,
            sse_customer_key=sse_customer_key,
            sts_endpoint=sts_endpoint,
            sts_region=sts_region,
            token=token,
            use_legacy_workflow=use_legacy_workflow,
            use_path_style=use_path_style,
            workspace_key_prefix=workspace_key_prefix,
        )

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


@jsii.data_type(
    jsii_type="cdktn.DataTerraformRemoteStateS3Config",
    jsii_struct_bases=[DataTerraformRemoteStateConfig, S3BackendConfig],
    name_mapping={
        "defaults": "defaults",
        "workspace": "workspace",
        "bucket": "bucket",
        "key": "key",
        "access_key": "accessKey",
        "acl": "acl",
        "allowed_account_ids": "allowedAccountIds",
        "assume_role": "assumeRole",
        "assume_role_policy": "assumeRolePolicy",
        "assume_role_policy_arns": "assumeRolePolicyArns",
        "assume_role_tags": "assumeRoleTags",
        "assume_role_transitive_tag_keys": "assumeRoleTransitiveTagKeys",
        "assume_role_with_web_identity": "assumeRoleWithWebIdentity",
        "custom_ca_bundle": "customCaBundle",
        "dynamodb_endpoint": "dynamodbEndpoint",
        "dynamodb_table": "dynamodbTable",
        "ec2_metadata_service_endpoint": "ec2MetadataServiceEndpoint",
        "ec2_metadata_service_endpoint_mode": "ec2MetadataServiceEndpointMode",
        "encrypt": "encrypt",
        "endpoint": "endpoint",
        "endpoints": "endpoints",
        "external_id": "externalId",
        "forbidden_account_ids": "forbiddenAccountIds",
        "force_path_style": "forcePathStyle",
        "http_proxy": "httpProxy",
        "https_proxy": "httpsProxy",
        "iam_endpoint": "iamEndpoint",
        "insecure": "insecure",
        "kms_key_id": "kmsKeyId",
        "max_retries": "maxRetries",
        "no_proxy": "noProxy",
        "profile": "profile",
        "region": "region",
        "retry_mode": "retryMode",
        "role_arn": "roleArn",
        "secret_key": "secretKey",
        "session_name": "sessionName",
        "shared_config_files": "sharedConfigFiles",
        "shared_credentials_file": "sharedCredentialsFile",
        "shared_credentials_files": "sharedCredentialsFiles",
        "skip_credentials_validation": "skipCredentialsValidation",
        "skip_metadata_api_check": "skipMetadataApiCheck",
        "skip_region_validation": "skipRegionValidation",
        "skip_requesting_account_id": "skipRequestingAccountId",
        "skip_s3_checksum": "skipS3Checksum",
        "sse_customer_key": "sseCustomerKey",
        "sts_endpoint": "stsEndpoint",
        "sts_region": "stsRegion",
        "token": "token",
        "use_legacy_workflow": "useLegacyWorkflow",
        "use_path_style": "usePathStyle",
        "workspace_key_prefix": "workspaceKeyPrefix",
    },
)
class DataTerraformRemoteStateS3Config(DataTerraformRemoteStateConfig, S3BackendConfig):
    def __init__(
        self,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        bucket: builtins.str,
        key: builtins.str,
        access_key: typing.Optional[builtins.str] = None,
        acl: typing.Optional[builtins.str] = None,
        allowed_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        assume_role: typing.Optional[typing.Union[S3BackendAssumeRoleConfig, typing.Dict[builtins.str, typing.Any]]] = None,
        assume_role_policy: typing.Optional[builtins.str] = None,
        assume_role_policy_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
        assume_role_tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        assume_role_transitive_tag_keys: typing.Optional[typing.Sequence[builtins.str]] = None,
        assume_role_with_web_identity: typing.Optional[typing.Union[S3BackendAssumeRoleWithWebIdentityConfig, typing.Dict[builtins.str, typing.Any]]] = None,
        custom_ca_bundle: typing.Optional[builtins.str] = None,
        dynamodb_endpoint: typing.Optional[builtins.str] = None,
        dynamodb_table: typing.Optional[builtins.str] = None,
        ec2_metadata_service_endpoint: typing.Optional[builtins.str] = None,
        ec2_metadata_service_endpoint_mode: typing.Optional[builtins.str] = None,
        encrypt: typing.Optional[builtins.bool] = None,
        endpoint: typing.Optional[builtins.str] = None,
        endpoints: typing.Optional[typing.Union[S3BackendEndpointConfig, typing.Dict[builtins.str, typing.Any]]] = None,
        external_id: typing.Optional[builtins.str] = None,
        forbidden_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        force_path_style: typing.Optional[builtins.bool] = None,
        http_proxy: typing.Optional[builtins.str] = None,
        https_proxy: typing.Optional[builtins.str] = None,
        iam_endpoint: typing.Optional[builtins.str] = None,
        insecure: typing.Optional[builtins.bool] = None,
        kms_key_id: typing.Optional[builtins.str] = None,
        max_retries: typing.Optional[jsii.Number] = None,
        no_proxy: typing.Optional[builtins.str] = None,
        profile: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        retry_mode: typing.Optional[builtins.str] = None,
        role_arn: typing.Optional[builtins.str] = None,
        secret_key: typing.Optional[builtins.str] = None,
        session_name: typing.Optional[builtins.str] = None,
        shared_config_files: typing.Optional[typing.Sequence[builtins.str]] = None,
        shared_credentials_file: typing.Optional[builtins.str] = None,
        shared_credentials_files: typing.Optional[typing.Sequence[builtins.str]] = None,
        skip_credentials_validation: typing.Optional[builtins.bool] = None,
        skip_metadata_api_check: typing.Optional[builtins.bool] = None,
        skip_region_validation: typing.Optional[builtins.bool] = None,
        skip_requesting_account_id: typing.Optional[builtins.bool] = None,
        skip_s3_checksum: typing.Optional[builtins.bool] = None,
        sse_customer_key: typing.Optional[builtins.str] = None,
        sts_endpoint: typing.Optional[builtins.str] = None,
        sts_region: typing.Optional[builtins.str] = None,
        token: typing.Optional[builtins.str] = None,
        use_legacy_workflow: typing.Optional[builtins.bool] = None,
        use_path_style: typing.Optional[builtins.bool] = None,
        workspace_key_prefix: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param defaults: 
        :param workspace: 
        :param bucket: (experimental) Name of the S3 Bucket.
        :param key: (experimental) Path to the state file inside the S3 Bucket. When using a non-default workspace, the state path will be /workspace_key_prefix/workspace_name/key
        :param access_key: (experimental) (Optional) AWS access key. If configured, must also configure secret_key. This can also be sourced from the AWS_ACCESS_KEY_ID environment variable, AWS shared credentials file (e.g. ~/.aws/credentials), or AWS shared configuration file (e.g. ~/.aws/config).
        :param acl: (experimental) (Optional) Canned ACL to be applied to the state file.
        :param allowed_account_ids: (experimental) (Optional) List of allowed AWS account IDs to prevent potential destruction of a live environment. Conflicts with forbidden_account_ids.
        :param assume_role: (experimental) Assuming an IAM Role can be configured in two ways. The preferred way is to use the argument assume_role, the other, which is deprecated, is with arguments at the top level.
        :param assume_role_policy: (deprecated) (Optional) IAM Policy JSON describing further restricting permissions for the IAM Role being assumed.
        :param assume_role_policy_arns: (deprecated) (Optional) Set of Amazon Resource Names (ARNs) of IAM Policies describing further restricting permissions for the IAM Role being assumed.
        :param assume_role_tags: (deprecated) (Optional) Map of assume role session tags.
        :param assume_role_transitive_tag_keys: (deprecated) (Optional) Set of assume role session tag keys to pass to any subsequent sessions.
        :param assume_role_with_web_identity: (experimental) Assume Role With Web Identity Configuration.
        :param custom_ca_bundle: (experimental) (Optional) File containing custom root and intermediate certificates. Can also be set using the AWS_CA_BUNDLE environment variable. Setting ca_bundle in the shared config file is not supported.
        :param dynamodb_endpoint: (deprecated) (Optional) Custom endpoint for the AWS DynamoDB API. This can also be sourced from the AWS_DYNAMODB_ENDPOINT environment variable.
        :param dynamodb_table: (experimental) (Optional) Name of DynamoDB Table to use for state locking and consistency. The table must have a partition key named LockID with type of String. If not configured, state locking will be disabled.
        :param ec2_metadata_service_endpoint: (experimental) Optional) Custom endpoint URL for the EC2 Instance Metadata Service (IMDS) API. Can also be set with the AWS_EC2_METADATA_SERVICE_ENDPOINT environment variable.
        :param ec2_metadata_service_endpoint_mode: (experimental) (Optional) Mode to use in communicating with the metadata service. Valid values are IPv4 and IPv6. Can also be set with the AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE environment variable.
        :param encrypt: (experimental) (Optional) Enable server side encryption of the state file.
        :param endpoint: (deprecated) (Optional) Custom endpoint for the AWS S3 API. This can also be sourced from the AWS_S3_ENDPOINT environment variable.
        :param endpoints: (experimental) (Optional) The endpoint configuration block.
        :param external_id: (deprecated) (Optional) External identifier to use when assuming the role.
        :param forbidden_account_ids: (experimental) (Optional) List of forbidden AWS account IDs to prevent potential destruction of a live environment. Conflicts with allowed_account_ids.
        :param force_path_style: (deprecated) (Optional) Enable path-style S3 URLs (https:/// instead of https://.).
        :param http_proxy: (experimental) (Optional) URL of a proxy to use for HTTP requests when accessing the AWS API. Can also be set using the HTTP_PROXY or http_proxy environment variables.
        :param https_proxy: (experimental) (Optional) URL of a proxy to use for HTTPS requests when accessing the AWS API. Can also be set using the HTTPS_PROXY or https_proxy environment variables.
        :param iam_endpoint: (deprecated) (Optional) Custom endpoint for the AWS Identity and Access Management (IAM) API. This can also be sourced from the AWS_IAM_ENDPOINT environment variable.
        :param insecure: (experimental) Optional) Whether to explicitly allow the backend to perform "insecure" SSL requests. If omitted, the default value is false.
        :param kms_key_id: (experimental) (Optional) Amazon Resource Name (ARN) of a Key Management Service (KMS) Key to use for encrypting the state. Note that if this value is specified, Terraform will need kms:Encrypt, kms:Decrypt and kms:GenerateDataKey permissions on this KMS key.
        :param max_retries: (experimental) (Optional) The maximum number of times an AWS API request is retried on retryable failure. Defaults to 5.
        :param no_proxy: (experimental) (Optional) Comma-separated list of hosts that should not use HTTP or HTTPS proxies. Each value can be one of: - A domain name - An IP address - A CIDR address - An asterisk (*), to indicate that no proxying should be performed Domain name and IP address values can also include a port number. Can also be set using the NO_PROXY or no_proxy environment variables.
        :param profile: (experimental) (Optional) Name of AWS profile in AWS shared credentials file (e.g. ~/.aws/credentials) or AWS shared configuration file (e.g. ~/.aws/config) to use for credentials and/or configuration. This can also be sourced from the AWS_PROFILE environment variable.
        :param region: (experimental) AWS Region of the S3 Bucket and DynamoDB Table (if used). This can also be sourced from the AWS_DEFAULT_REGION and AWS_REGION environment variables.
        :param retry_mode: (experimental) (Optional) Specifies how retries are attempted. Valid values are standard and adaptive. Can also be configured using the AWS_RETRY_MODE environment variable or the shared config file parameter retry_mode.
        :param role_arn: (deprecated) (Optional) Amazon Resource Name (ARN) of the IAM Role to assume.
        :param secret_key: (experimental) (Optional) AWS secret access key. If configured, must also configure access_key. This can also be sourced from the AWS_SECRET_ACCESS_KEY environment variable, AWS shared credentials file (e.g. ~/.aws/credentials), or AWS shared configuration file (e.g. ~/.aws/config)
        :param session_name: (deprecated) (Optional) Session name to use when assuming the role.
        :param shared_config_files: (experimental) (Optional) List of paths to AWS shared configuration files. Defaults to ~/.aws/config.
        :param shared_credentials_file: (experimental) (Optional) Path to the AWS shared credentials file. Defaults to ~/.aws/credentials.
        :param shared_credentials_files: (experimental) (Optional) List of paths to AWS shared credentials files. Defaults to ~/.aws/credentials.
        :param skip_credentials_validation: (experimental) (Optional) Skip credentials validation via the STS API.
        :param skip_metadata_api_check: (experimental) (Optional) Skip usage of EC2 Metadata API.
        :param skip_region_validation: (experimental) (Optional) Skip validation of provided region name.
        :param skip_requesting_account_id: (experimental) (Optional) Whether to skip requesting the account ID. Useful for AWS API implementations that do not have the IAM, STS API, or metadata API.
        :param skip_s3_checksum: (experimental) (Optional) Do not include checksum when uploading S3 Objects. Useful for some S3-Compatible APIs.
        :param sse_customer_key: (experimental) (Optional) The key to use for encrypting state with Server-Side Encryption with Customer-Provided Keys (SSE-C). This is the base64-encoded value of the key, which must decode to 256 bits. This can also be sourced from the AWS_SSE_CUSTOMER_KEY environment variable, which is recommended due to the sensitivity of the value. Setting it inside a terraform file will cause it to be persisted to disk in terraform.tfstate.
        :param sts_endpoint: (deprecated) (Optional) Custom endpoint for the AWS Security Token Service (STS) API. This can also be sourced from the AWS_STS_ENDPOINT environment variable.
        :param sts_region: (experimental) (Optional) AWS region for STS. If unset, AWS will use the same region for STS as other non-STS operations.
        :param token: (experimental) (Optional) Multi-Factor Authentication (MFA) token. This can also be sourced from the AWS_SESSION_TOKEN environment variable.
        :param use_legacy_workflow: (experimental) (Optional) Use the legacy authentication workflow, preferring environment variables over backend configuration. Defaults to true. This behavior does not align with the authentication flow of the AWS CLI or SDK's, and will be removed in the future.
        :param use_path_style: (experimental) (Optional) Enable path-style S3 URLs (https:/// instead of https://.).
        :param workspace_key_prefix: (experimental) (Optional) Prefix applied to the state path inside the bucket. This is only relevant when using a non-default workspace. Defaults to env:

        :stability: experimental
        '''
        if isinstance(assume_role, dict):
            assume_role = S3BackendAssumeRoleConfig(**assume_role)
        if isinstance(assume_role_with_web_identity, dict):
            assume_role_with_web_identity = S3BackendAssumeRoleWithWebIdentityConfig(**assume_role_with_web_identity)
        if isinstance(endpoints, dict):
            endpoints = S3BackendEndpointConfig(**endpoints)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__854b50f50b4391053c1124f2240fe5425fe0f99b959021463c404f1fff738dc4)
            check_type(argname="argument defaults", value=defaults, expected_type=type_hints["defaults"])
            check_type(argname="argument workspace", value=workspace, expected_type=type_hints["workspace"])
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
            check_type(argname="argument access_key", value=access_key, expected_type=type_hints["access_key"])
            check_type(argname="argument acl", value=acl, expected_type=type_hints["acl"])
            check_type(argname="argument allowed_account_ids", value=allowed_account_ids, expected_type=type_hints["allowed_account_ids"])
            check_type(argname="argument assume_role", value=assume_role, expected_type=type_hints["assume_role"])
            check_type(argname="argument assume_role_policy", value=assume_role_policy, expected_type=type_hints["assume_role_policy"])
            check_type(argname="argument assume_role_policy_arns", value=assume_role_policy_arns, expected_type=type_hints["assume_role_policy_arns"])
            check_type(argname="argument assume_role_tags", value=assume_role_tags, expected_type=type_hints["assume_role_tags"])
            check_type(argname="argument assume_role_transitive_tag_keys", value=assume_role_transitive_tag_keys, expected_type=type_hints["assume_role_transitive_tag_keys"])
            check_type(argname="argument assume_role_with_web_identity", value=assume_role_with_web_identity, expected_type=type_hints["assume_role_with_web_identity"])
            check_type(argname="argument custom_ca_bundle", value=custom_ca_bundle, expected_type=type_hints["custom_ca_bundle"])
            check_type(argname="argument dynamodb_endpoint", value=dynamodb_endpoint, expected_type=type_hints["dynamodb_endpoint"])
            check_type(argname="argument dynamodb_table", value=dynamodb_table, expected_type=type_hints["dynamodb_table"])
            check_type(argname="argument ec2_metadata_service_endpoint", value=ec2_metadata_service_endpoint, expected_type=type_hints["ec2_metadata_service_endpoint"])
            check_type(argname="argument ec2_metadata_service_endpoint_mode", value=ec2_metadata_service_endpoint_mode, expected_type=type_hints["ec2_metadata_service_endpoint_mode"])
            check_type(argname="argument encrypt", value=encrypt, expected_type=type_hints["encrypt"])
            check_type(argname="argument endpoint", value=endpoint, expected_type=type_hints["endpoint"])
            check_type(argname="argument endpoints", value=endpoints, expected_type=type_hints["endpoints"])
            check_type(argname="argument external_id", value=external_id, expected_type=type_hints["external_id"])
            check_type(argname="argument forbidden_account_ids", value=forbidden_account_ids, expected_type=type_hints["forbidden_account_ids"])
            check_type(argname="argument force_path_style", value=force_path_style, expected_type=type_hints["force_path_style"])
            check_type(argname="argument http_proxy", value=http_proxy, expected_type=type_hints["http_proxy"])
            check_type(argname="argument https_proxy", value=https_proxy, expected_type=type_hints["https_proxy"])
            check_type(argname="argument iam_endpoint", value=iam_endpoint, expected_type=type_hints["iam_endpoint"])
            check_type(argname="argument insecure", value=insecure, expected_type=type_hints["insecure"])
            check_type(argname="argument kms_key_id", value=kms_key_id, expected_type=type_hints["kms_key_id"])
            check_type(argname="argument max_retries", value=max_retries, expected_type=type_hints["max_retries"])
            check_type(argname="argument no_proxy", value=no_proxy, expected_type=type_hints["no_proxy"])
            check_type(argname="argument profile", value=profile, expected_type=type_hints["profile"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument retry_mode", value=retry_mode, expected_type=type_hints["retry_mode"])
            check_type(argname="argument role_arn", value=role_arn, expected_type=type_hints["role_arn"])
            check_type(argname="argument secret_key", value=secret_key, expected_type=type_hints["secret_key"])
            check_type(argname="argument session_name", value=session_name, expected_type=type_hints["session_name"])
            check_type(argname="argument shared_config_files", value=shared_config_files, expected_type=type_hints["shared_config_files"])
            check_type(argname="argument shared_credentials_file", value=shared_credentials_file, expected_type=type_hints["shared_credentials_file"])
            check_type(argname="argument shared_credentials_files", value=shared_credentials_files, expected_type=type_hints["shared_credentials_files"])
            check_type(argname="argument skip_credentials_validation", value=skip_credentials_validation, expected_type=type_hints["skip_credentials_validation"])
            check_type(argname="argument skip_metadata_api_check", value=skip_metadata_api_check, expected_type=type_hints["skip_metadata_api_check"])
            check_type(argname="argument skip_region_validation", value=skip_region_validation, expected_type=type_hints["skip_region_validation"])
            check_type(argname="argument skip_requesting_account_id", value=skip_requesting_account_id, expected_type=type_hints["skip_requesting_account_id"])
            check_type(argname="argument skip_s3_checksum", value=skip_s3_checksum, expected_type=type_hints["skip_s3_checksum"])
            check_type(argname="argument sse_customer_key", value=sse_customer_key, expected_type=type_hints["sse_customer_key"])
            check_type(argname="argument sts_endpoint", value=sts_endpoint, expected_type=type_hints["sts_endpoint"])
            check_type(argname="argument sts_region", value=sts_region, expected_type=type_hints["sts_region"])
            check_type(argname="argument token", value=token, expected_type=type_hints["token"])
            check_type(argname="argument use_legacy_workflow", value=use_legacy_workflow, expected_type=type_hints["use_legacy_workflow"])
            check_type(argname="argument use_path_style", value=use_path_style, expected_type=type_hints["use_path_style"])
            check_type(argname="argument workspace_key_prefix", value=workspace_key_prefix, expected_type=type_hints["workspace_key_prefix"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bucket": bucket,
            "key": key,
        }
        if defaults is not None:
            self._values["defaults"] = defaults
        if workspace is not None:
            self._values["workspace"] = workspace
        if access_key is not None:
            self._values["access_key"] = access_key
        if acl is not None:
            self._values["acl"] = acl
        if allowed_account_ids is not None:
            self._values["allowed_account_ids"] = allowed_account_ids
        if assume_role is not None:
            self._values["assume_role"] = assume_role
        if assume_role_policy is not None:
            self._values["assume_role_policy"] = assume_role_policy
        if assume_role_policy_arns is not None:
            self._values["assume_role_policy_arns"] = assume_role_policy_arns
        if assume_role_tags is not None:
            self._values["assume_role_tags"] = assume_role_tags
        if assume_role_transitive_tag_keys is not None:
            self._values["assume_role_transitive_tag_keys"] = assume_role_transitive_tag_keys
        if assume_role_with_web_identity is not None:
            self._values["assume_role_with_web_identity"] = assume_role_with_web_identity
        if custom_ca_bundle is not None:
            self._values["custom_ca_bundle"] = custom_ca_bundle
        if dynamodb_endpoint is not None:
            self._values["dynamodb_endpoint"] = dynamodb_endpoint
        if dynamodb_table is not None:
            self._values["dynamodb_table"] = dynamodb_table
        if ec2_metadata_service_endpoint is not None:
            self._values["ec2_metadata_service_endpoint"] = ec2_metadata_service_endpoint
        if ec2_metadata_service_endpoint_mode is not None:
            self._values["ec2_metadata_service_endpoint_mode"] = ec2_metadata_service_endpoint_mode
        if encrypt is not None:
            self._values["encrypt"] = encrypt
        if endpoint is not None:
            self._values["endpoint"] = endpoint
        if endpoints is not None:
            self._values["endpoints"] = endpoints
        if external_id is not None:
            self._values["external_id"] = external_id
        if forbidden_account_ids is not None:
            self._values["forbidden_account_ids"] = forbidden_account_ids
        if force_path_style is not None:
            self._values["force_path_style"] = force_path_style
        if http_proxy is not None:
            self._values["http_proxy"] = http_proxy
        if https_proxy is not None:
            self._values["https_proxy"] = https_proxy
        if iam_endpoint is not None:
            self._values["iam_endpoint"] = iam_endpoint
        if insecure is not None:
            self._values["insecure"] = insecure
        if kms_key_id is not None:
            self._values["kms_key_id"] = kms_key_id
        if max_retries is not None:
            self._values["max_retries"] = max_retries
        if no_proxy is not None:
            self._values["no_proxy"] = no_proxy
        if profile is not None:
            self._values["profile"] = profile
        if region is not None:
            self._values["region"] = region
        if retry_mode is not None:
            self._values["retry_mode"] = retry_mode
        if role_arn is not None:
            self._values["role_arn"] = role_arn
        if secret_key is not None:
            self._values["secret_key"] = secret_key
        if session_name is not None:
            self._values["session_name"] = session_name
        if shared_config_files is not None:
            self._values["shared_config_files"] = shared_config_files
        if shared_credentials_file is not None:
            self._values["shared_credentials_file"] = shared_credentials_file
        if shared_credentials_files is not None:
            self._values["shared_credentials_files"] = shared_credentials_files
        if skip_credentials_validation is not None:
            self._values["skip_credentials_validation"] = skip_credentials_validation
        if skip_metadata_api_check is not None:
            self._values["skip_metadata_api_check"] = skip_metadata_api_check
        if skip_region_validation is not None:
            self._values["skip_region_validation"] = skip_region_validation
        if skip_requesting_account_id is not None:
            self._values["skip_requesting_account_id"] = skip_requesting_account_id
        if skip_s3_checksum is not None:
            self._values["skip_s3_checksum"] = skip_s3_checksum
        if sse_customer_key is not None:
            self._values["sse_customer_key"] = sse_customer_key
        if sts_endpoint is not None:
            self._values["sts_endpoint"] = sts_endpoint
        if sts_region is not None:
            self._values["sts_region"] = sts_region
        if token is not None:
            self._values["token"] = token
        if use_legacy_workflow is not None:
            self._values["use_legacy_workflow"] = use_legacy_workflow
        if use_path_style is not None:
            self._values["use_path_style"] = use_path_style
        if workspace_key_prefix is not None:
            self._values["workspace_key_prefix"] = workspace_key_prefix

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

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

    @builtins.property
    def bucket(self) -> builtins.str:
        '''(experimental) Name of the S3 Bucket.

        :stability: experimental
        '''
        result = self._values.get("bucket")
        assert result is not None, "Required property 'bucket' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def key(self) -> builtins.str:
        '''(experimental) Path to the state file inside the S3 Bucket.

        When using a non-default workspace, the state path will be /workspace_key_prefix/workspace_name/key

        :stability: experimental
        '''
        result = self._values.get("key")
        assert result is not None, "Required property 'key' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def access_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) AWS access key.

        If configured, must also configure secret_key.
        This can also be sourced from
        the AWS_ACCESS_KEY_ID environment variable,
        AWS shared credentials file (e.g. ~/.aws/credentials),
        or AWS shared configuration file (e.g. ~/.aws/config).

        :stability: experimental
        '''
        result = self._values.get("access_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def acl(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Canned ACL to be applied to the state file.

        :stability: experimental
        '''
        result = self._values.get("acl")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def allowed_account_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) (Optional) List of allowed AWS account IDs to prevent potential destruction of a live environment.

        Conflicts with forbidden_account_ids.

        :stability: experimental
        '''
        result = self._values.get("allowed_account_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def assume_role(self) -> typing.Optional[S3BackendAssumeRoleConfig]:
        '''(experimental) Assuming an IAM Role can be configured in two ways.

        The preferred way is to use the argument assume_role, the other, which is deprecated, is with arguments at the top level.

        :stability: experimental
        '''
        result = self._values.get("assume_role")
        return typing.cast(typing.Optional[S3BackendAssumeRoleConfig], result)

    @builtins.property
    def assume_role_policy(self) -> typing.Optional[builtins.str]:
        '''(deprecated) (Optional) IAM Policy JSON describing further restricting permissions for the IAM Role being assumed.

        :deprecated: Use assumeRole.policy instead.

        :stability: deprecated
        '''
        result = self._values.get("assume_role_policy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def assume_role_policy_arns(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(deprecated) (Optional) Set of Amazon Resource Names (ARNs) of IAM Policies describing further restricting permissions for the IAM Role being assumed.

        :deprecated: Use assumeRole.policyArns instead.

        :stability: deprecated
        '''
        result = self._values.get("assume_role_policy_arns")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def assume_role_tags(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        '''(deprecated) (Optional) Map of assume role session tags.

        :deprecated: Use assumeRole.tags instead.

        :stability: deprecated
        '''
        result = self._values.get("assume_role_tags")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    @builtins.property
    def assume_role_transitive_tag_keys(
        self,
    ) -> typing.Optional[typing.List[builtins.str]]:
        '''(deprecated) (Optional) Set of assume role session tag keys to pass to any subsequent sessions.

        :deprecated: Use assumeRole.transitiveTagKeys instead.

        :stability: deprecated
        '''
        result = self._values.get("assume_role_transitive_tag_keys")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def assume_role_with_web_identity(
        self,
    ) -> typing.Optional[S3BackendAssumeRoleWithWebIdentityConfig]:
        '''(experimental) Assume Role With Web Identity Configuration.

        :stability: experimental
        '''
        result = self._values.get("assume_role_with_web_identity")
        return typing.cast(typing.Optional[S3BackendAssumeRoleWithWebIdentityConfig], result)

    @builtins.property
    def custom_ca_bundle(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) File containing custom root and intermediate certificates.

        Can also be set using the AWS_CA_BUNDLE environment variable.
        Setting ca_bundle in the shared config file is not supported.

        :stability: experimental
        '''
        result = self._values.get("custom_ca_bundle")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def dynamodb_endpoint(self) -> typing.Optional[builtins.str]:
        '''(deprecated) (Optional) Custom endpoint for the AWS DynamoDB API.

        This can also be sourced from the AWS_DYNAMODB_ENDPOINT environment variable.

        :deprecated: Use endpoints.dynamodb instead

        :stability: deprecated
        '''
        result = self._values.get("dynamodb_endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def dynamodb_table(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Name of DynamoDB Table to use for state locking and consistency.

        The table must have a partition key named LockID with type of String.
        If not configured, state locking will be disabled.

        :stability: experimental
        '''
        result = self._values.get("dynamodb_table")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ec2_metadata_service_endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) Optional) Custom endpoint URL for the EC2 Instance Metadata Service (IMDS) API.

        Can also be set with the AWS_EC2_METADATA_SERVICE_ENDPOINT environment variable.

        :stability: experimental
        '''
        result = self._values.get("ec2_metadata_service_endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ec2_metadata_service_endpoint_mode(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Mode to use in communicating with the metadata service.

        Valid values are IPv4 and IPv6.
        Can also be set with the AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE environment variable.

        :stability: experimental
        '''
        result = self._values.get("ec2_metadata_service_endpoint_mode")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def encrypt(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Enable server side encryption of the state file.

        :stability: experimental
        '''
        result = self._values.get("encrypt")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def endpoint(self) -> typing.Optional[builtins.str]:
        '''(deprecated) (Optional) Custom endpoint for the AWS S3 API.

        This can also be sourced from the AWS_S3_ENDPOINT environment variable.

        :deprecated: Use endpoints.s3 instead

        :stability: deprecated
        '''
        result = self._values.get("endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def endpoints(self) -> typing.Optional[S3BackendEndpointConfig]:
        '''(experimental) (Optional) The endpoint configuration block.

        :stability: experimental
        '''
        result = self._values.get("endpoints")
        return typing.cast(typing.Optional[S3BackendEndpointConfig], result)

    @builtins.property
    def external_id(self) -> typing.Optional[builtins.str]:
        '''(deprecated) (Optional) External identifier to use when assuming the role.

        :deprecated: Use assume_role.external_id instead.

        :stability: deprecated
        '''
        result = self._values.get("external_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def forbidden_account_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) (Optional) List of forbidden AWS account IDs to prevent potential destruction of a live environment.

        Conflicts with allowed_account_ids.

        :stability: experimental
        '''
        result = self._values.get("forbidden_account_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def force_path_style(self) -> typing.Optional[builtins.bool]:
        '''(deprecated) (Optional) Enable path-style S3 URLs (https:/// instead of https://.).

        :deprecated: Use usePathStyle instead

        :stability: deprecated
        '''
        result = self._values.get("force_path_style")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def http_proxy(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) URL of a proxy to use for HTTP requests when accessing the AWS API.

        Can also be set using the HTTP_PROXY or http_proxy environment variables.

        :stability: experimental
        '''
        result = self._values.get("http_proxy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def https_proxy(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) URL of a proxy to use for HTTPS requests when accessing the AWS API.

        Can also be set using the HTTPS_PROXY or https_proxy environment variables.

        :stability: experimental
        '''
        result = self._values.get("https_proxy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def iam_endpoint(self) -> typing.Optional[builtins.str]:
        '''(deprecated) (Optional) Custom endpoint for the AWS Identity and Access Management (IAM) API.

        This can also be sourced from the AWS_IAM_ENDPOINT environment variable.

        :deprecated: Use endpoints.iam instead

        :stability: deprecated
        '''
        result = self._values.get("iam_endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def insecure(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Optional) Whether to explicitly allow the backend to perform "insecure" SSL requests.

        If omitted, the default value is false.

        :stability: experimental
        '''
        result = self._values.get("insecure")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def kms_key_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Amazon Resource Name (ARN) of a Key Management Service (KMS) Key to use for encrypting the state.

        Note that if this value is specified,
        Terraform will need kms:Encrypt, kms:Decrypt and kms:GenerateDataKey permissions on this KMS key.

        :stability: experimental
        '''
        result = self._values.get("kms_key_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def max_retries(self) -> typing.Optional[jsii.Number]:
        '''(experimental) (Optional) The maximum number of times an AWS API request is retried on retryable failure.

        Defaults to 5.

        :stability: experimental
        '''
        result = self._values.get("max_retries")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def no_proxy(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Comma-separated list of hosts that should not use HTTP or HTTPS proxies.

        Each value can be one of:

        - A domain name
        - An IP address
        - A CIDR address
        - An asterisk (*), to indicate that no proxying should be performed Domain name and IP address values can also include a port number.
          Can also be set using the NO_PROXY or no_proxy environment variables.

        :stability: experimental
        '''
        result = self._values.get("no_proxy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def profile(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Name of AWS profile in AWS shared credentials file (e.g. ~/.aws/credentials) or AWS shared configuration file (e.g. ~/.aws/config) to use for credentials and/or configuration. This can also be sourced from the AWS_PROFILE environment variable.

        :stability: experimental
        '''
        result = self._values.get("profile")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) AWS Region of the S3 Bucket and DynamoDB Table (if used).

        This can also
        be sourced from the AWS_DEFAULT_REGION and AWS_REGION environment
        variables.

        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def retry_mode(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Specifies how retries are attempted.

        Valid values are standard and adaptive.
        Can also be configured using the AWS_RETRY_MODE environment variable or the shared config file parameter retry_mode.

        :stability: experimental
        '''
        result = self._values.get("retry_mode")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def role_arn(self) -> typing.Optional[builtins.str]:
        '''(deprecated) (Optional) Amazon Resource Name (ARN) of the IAM Role to assume.

        :deprecated: Use assumeRole.roleArn instead.

        :stability: deprecated
        '''
        result = self._values.get("role_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def secret_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) AWS secret access key.

        If configured, must also configure access_key.
        This can also be sourced from
        the AWS_SECRET_ACCESS_KEY environment variable,
        AWS shared credentials file (e.g. ~/.aws/credentials),
        or AWS shared configuration file (e.g. ~/.aws/config)

        :stability: experimental
        '''
        result = self._values.get("secret_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def session_name(self) -> typing.Optional[builtins.str]:
        '''(deprecated) (Optional) Session name to use when assuming the role.

        :deprecated: Use assumeRole.sessionName instead.

        :stability: deprecated
        '''
        result = self._values.get("session_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def shared_config_files(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) (Optional) List of paths to AWS shared configuration files.

        Defaults to ~/.aws/config.

        :stability: experimental
        '''
        result = self._values.get("shared_config_files")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def shared_credentials_file(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Path to the AWS shared credentials file.

        Defaults to ~/.aws/credentials.

        :stability: experimental
        '''
        result = self._values.get("shared_credentials_file")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def shared_credentials_files(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) (Optional) List of paths to AWS shared credentials files.

        Defaults to ~/.aws/credentials.

        :stability: experimental
        '''
        result = self._values.get("shared_credentials_files")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def skip_credentials_validation(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Skip credentials validation via the STS API.

        :stability: experimental
        '''
        result = self._values.get("skip_credentials_validation")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def skip_metadata_api_check(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Skip usage of EC2 Metadata API.

        :stability: experimental
        '''
        result = self._values.get("skip_metadata_api_check")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def skip_region_validation(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Skip validation of provided region name.

        :stability: experimental
        '''
        result = self._values.get("skip_region_validation")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def skip_requesting_account_id(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Whether to skip requesting the account ID.

        Useful for AWS API implementations that do not have the IAM, STS API, or metadata API.

        :stability: experimental
        '''
        result = self._values.get("skip_requesting_account_id")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def skip_s3_checksum(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Do not include checksum when uploading S3 Objects.

        Useful for some S3-Compatible APIs.

        :stability: experimental
        '''
        result = self._values.get("skip_s3_checksum")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def sse_customer_key(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) The key to use for encrypting state with Server-Side Encryption with Customer-Provided Keys (SSE-C).

        This is the base64-encoded value of the key, which must decode to 256 bits.
        This can also be sourced from the AWS_SSE_CUSTOMER_KEY environment variable,
        which is recommended due to the sensitivity of the value.
        Setting it inside a terraform file will cause it to be persisted to disk in terraform.tfstate.

        :stability: experimental
        '''
        result = self._values.get("sse_customer_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sts_endpoint(self) -> typing.Optional[builtins.str]:
        '''(deprecated) (Optional) Custom endpoint for the AWS Security Token Service (STS) API.

        This can also be sourced from the AWS_STS_ENDPOINT environment variable.

        :deprecated: Use endpoints.sts instead

        :stability: deprecated
        '''
        result = self._values.get("sts_endpoint")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sts_region(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) AWS region for STS.

        If unset, AWS will use the same region for STS as other non-STS operations.

        :stability: experimental
        '''
        result = self._values.get("sts_region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def token(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Multi-Factor Authentication (MFA) token.

        This can also be sourced from the AWS_SESSION_TOKEN environment variable.

        :stability: experimental
        '''
        result = self._values.get("token")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def use_legacy_workflow(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Use the legacy authentication workflow, preferring environment variables over backend configuration.

        Defaults to true.
        This behavior does not align with the authentication flow of the AWS CLI or SDK's, and will be removed in the future.

        :stability: experimental
        '''
        result = self._values.get("use_legacy_workflow")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_path_style(self) -> typing.Optional[builtins.bool]:
        '''(experimental) (Optional) Enable path-style S3 URLs (https:/// instead of https://.).

        :stability: experimental
        '''
        result = self._values.get("use_path_style")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def workspace_key_prefix(self) -> typing.Optional[builtins.str]:
        '''(experimental) (Optional) Prefix applied to the state path inside the bucket.

        This is only relevant when using a non-default workspace. Defaults to env:

        :stability: experimental
        '''
        result = self._values.get("workspace_key_prefix")
        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 "DataTerraformRemoteStateS3Config(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class DataTerraformRemoteStateSwift(
    TerraformRemoteState,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.DataTerraformRemoteStateSwift",
):
    '''
    :deprecated: CDK for Terraform no longer supports the swift backend. Terraform deprecated swift in v1.2.3 and removed it in v1.3.

    :stability: deprecated
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        container: builtins.str,
        application_credential_id: typing.Optional[builtins.str] = None,
        application_credential_name: typing.Optional[builtins.str] = None,
        application_credential_secret: typing.Optional[builtins.str] = None,
        archive_container: typing.Optional[builtins.str] = None,
        auth_url: typing.Optional[builtins.str] = None,
        cacert_file: typing.Optional[builtins.str] = None,
        cert: typing.Optional[builtins.str] = None,
        cloud: typing.Optional[builtins.str] = None,
        default_domain: typing.Optional[builtins.str] = None,
        domain_id: typing.Optional[builtins.str] = None,
        domain_name: typing.Optional[builtins.str] = None,
        expire_after: typing.Optional[builtins.str] = None,
        insecure: typing.Optional[builtins.bool] = None,
        key: typing.Optional[builtins.str] = None,
        password: typing.Optional[builtins.str] = None,
        project_domain_id: typing.Optional[builtins.str] = None,
        project_domain_name: typing.Optional[builtins.str] = None,
        region_name: typing.Optional[builtins.str] = None,
        state_name: typing.Optional[builtins.str] = None,
        tenant_id: typing.Optional[builtins.str] = None,
        tenant_name: typing.Optional[builtins.str] = None,
        token: typing.Optional[builtins.str] = None,
        user_domain_id: typing.Optional[builtins.str] = None,
        user_domain_name: typing.Optional[builtins.str] = None,
        user_id: typing.Optional[builtins.str] = None,
        user_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param defaults: 
        :param workspace: 
        :param container: 
        :param application_credential_id: 
        :param application_credential_name: 
        :param application_credential_secret: 
        :param archive_container: 
        :param auth_url: 
        :param cacert_file: 
        :param cert: 
        :param cloud: 
        :param default_domain: 
        :param domain_id: 
        :param domain_name: 
        :param expire_after: 
        :param insecure: 
        :param key: 
        :param password: 
        :param project_domain_id: 
        :param project_domain_name: 
        :param region_name: 
        :param state_name: 
        :param tenant_id: 
        :param tenant_name: 
        :param token: 
        :param user_domain_id: 
        :param user_domain_name: 
        :param user_id: 
        :param user_name: 

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a7b949ef22206fbefe3532cbf8f6d07008c651dded9112233bc0fa83d9b485e6)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = DataTerraformRemoteStateSwiftConfig(
            defaults=defaults,
            workspace=workspace,
            container=container,
            application_credential_id=application_credential_id,
            application_credential_name=application_credential_name,
            application_credential_secret=application_credential_secret,
            archive_container=archive_container,
            auth_url=auth_url,
            cacert_file=cacert_file,
            cert=cert,
            cloud=cloud,
            default_domain=default_domain,
            domain_id=domain_id,
            domain_name=domain_name,
            expire_after=expire_after,
            insecure=insecure,
            key=key,
            password=password,
            project_domain_id=project_domain_id,
            project_domain_name=project_domain_name,
            region_name=region_name,
            state_name=state_name,
            tenant_id=tenant_id,
            tenant_name=tenant_name,
            token=token,
            user_domain_id=user_domain_id,
            user_domain_name=user_domain_name,
            user_id=user_id,
            user_name=user_name,
        )

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


@jsii.data_type(
    jsii_type="cdktn.DataTerraformRemoteStateSwiftConfig",
    jsii_struct_bases=[DataTerraformRemoteStateConfig, SwiftBackendConfig],
    name_mapping={
        "defaults": "defaults",
        "workspace": "workspace",
        "container": "container",
        "application_credential_id": "applicationCredentialId",
        "application_credential_name": "applicationCredentialName",
        "application_credential_secret": "applicationCredentialSecret",
        "archive_container": "archiveContainer",
        "auth_url": "authUrl",
        "cacert_file": "cacertFile",
        "cert": "cert",
        "cloud": "cloud",
        "default_domain": "defaultDomain",
        "domain_id": "domainId",
        "domain_name": "domainName",
        "expire_after": "expireAfter",
        "insecure": "insecure",
        "key": "key",
        "password": "password",
        "project_domain_id": "projectDomainId",
        "project_domain_name": "projectDomainName",
        "region_name": "regionName",
        "state_name": "stateName",
        "tenant_id": "tenantId",
        "tenant_name": "tenantName",
        "token": "token",
        "user_domain_id": "userDomainId",
        "user_domain_name": "userDomainName",
        "user_id": "userId",
        "user_name": "userName",
    },
)
class DataTerraformRemoteStateSwiftConfig(
    DataTerraformRemoteStateConfig,
    SwiftBackendConfig,
):
    def __init__(
        self,
        *,
        defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        workspace: typing.Optional[builtins.str] = None,
        container: builtins.str,
        application_credential_id: typing.Optional[builtins.str] = None,
        application_credential_name: typing.Optional[builtins.str] = None,
        application_credential_secret: typing.Optional[builtins.str] = None,
        archive_container: typing.Optional[builtins.str] = None,
        auth_url: typing.Optional[builtins.str] = None,
        cacert_file: typing.Optional[builtins.str] = None,
        cert: typing.Optional[builtins.str] = None,
        cloud: typing.Optional[builtins.str] = None,
        default_domain: typing.Optional[builtins.str] = None,
        domain_id: typing.Optional[builtins.str] = None,
        domain_name: typing.Optional[builtins.str] = None,
        expire_after: typing.Optional[builtins.str] = None,
        insecure: typing.Optional[builtins.bool] = None,
        key: typing.Optional[builtins.str] = None,
        password: typing.Optional[builtins.str] = None,
        project_domain_id: typing.Optional[builtins.str] = None,
        project_domain_name: typing.Optional[builtins.str] = None,
        region_name: typing.Optional[builtins.str] = None,
        state_name: typing.Optional[builtins.str] = None,
        tenant_id: typing.Optional[builtins.str] = None,
        tenant_name: typing.Optional[builtins.str] = None,
        token: typing.Optional[builtins.str] = None,
        user_domain_id: typing.Optional[builtins.str] = None,
        user_domain_name: typing.Optional[builtins.str] = None,
        user_id: typing.Optional[builtins.str] = None,
        user_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param defaults: 
        :param workspace: 
        :param container: 
        :param application_credential_id: 
        :param application_credential_name: 
        :param application_credential_secret: 
        :param archive_container: 
        :param auth_url: 
        :param cacert_file: 
        :param cert: 
        :param cloud: 
        :param default_domain: 
        :param domain_id: 
        :param domain_name: 
        :param expire_after: 
        :param insecure: 
        :param key: 
        :param password: 
        :param project_domain_id: 
        :param project_domain_name: 
        :param region_name: 
        :param state_name: 
        :param tenant_id: 
        :param tenant_name: 
        :param token: 
        :param user_domain_id: 
        :param user_domain_name: 
        :param user_id: 
        :param user_name: 

        :deprecated: CDK for Terraform no longer supports the swift backend. Terraform deprecated swift in v1.2.3 and removed it in v1.3.

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a21fb45814156b194363fd70ca255c3d57c3e2547dfe878e8b876d2c74e898da)
            check_type(argname="argument defaults", value=defaults, expected_type=type_hints["defaults"])
            check_type(argname="argument workspace", value=workspace, expected_type=type_hints["workspace"])
            check_type(argname="argument container", value=container, expected_type=type_hints["container"])
            check_type(argname="argument application_credential_id", value=application_credential_id, expected_type=type_hints["application_credential_id"])
            check_type(argname="argument application_credential_name", value=application_credential_name, expected_type=type_hints["application_credential_name"])
            check_type(argname="argument application_credential_secret", value=application_credential_secret, expected_type=type_hints["application_credential_secret"])
            check_type(argname="argument archive_container", value=archive_container, expected_type=type_hints["archive_container"])
            check_type(argname="argument auth_url", value=auth_url, expected_type=type_hints["auth_url"])
            check_type(argname="argument cacert_file", value=cacert_file, expected_type=type_hints["cacert_file"])
            check_type(argname="argument cert", value=cert, expected_type=type_hints["cert"])
            check_type(argname="argument cloud", value=cloud, expected_type=type_hints["cloud"])
            check_type(argname="argument default_domain", value=default_domain, expected_type=type_hints["default_domain"])
            check_type(argname="argument domain_id", value=domain_id, expected_type=type_hints["domain_id"])
            check_type(argname="argument domain_name", value=domain_name, expected_type=type_hints["domain_name"])
            check_type(argname="argument expire_after", value=expire_after, expected_type=type_hints["expire_after"])
            check_type(argname="argument insecure", value=insecure, expected_type=type_hints["insecure"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
            check_type(argname="argument password", value=password, expected_type=type_hints["password"])
            check_type(argname="argument project_domain_id", value=project_domain_id, expected_type=type_hints["project_domain_id"])
            check_type(argname="argument project_domain_name", value=project_domain_name, expected_type=type_hints["project_domain_name"])
            check_type(argname="argument region_name", value=region_name, expected_type=type_hints["region_name"])
            check_type(argname="argument state_name", value=state_name, expected_type=type_hints["state_name"])
            check_type(argname="argument tenant_id", value=tenant_id, expected_type=type_hints["tenant_id"])
            check_type(argname="argument tenant_name", value=tenant_name, expected_type=type_hints["tenant_name"])
            check_type(argname="argument token", value=token, expected_type=type_hints["token"])
            check_type(argname="argument user_domain_id", value=user_domain_id, expected_type=type_hints["user_domain_id"])
            check_type(argname="argument user_domain_name", value=user_domain_name, expected_type=type_hints["user_domain_name"])
            check_type(argname="argument user_id", value=user_id, expected_type=type_hints["user_id"])
            check_type(argname="argument user_name", value=user_name, expected_type=type_hints["user_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "container": container,
        }
        if defaults is not None:
            self._values["defaults"] = defaults
        if workspace is not None:
            self._values["workspace"] = workspace
        if application_credential_id is not None:
            self._values["application_credential_id"] = application_credential_id
        if application_credential_name is not None:
            self._values["application_credential_name"] = application_credential_name
        if application_credential_secret is not None:
            self._values["application_credential_secret"] = application_credential_secret
        if archive_container is not None:
            self._values["archive_container"] = archive_container
        if auth_url is not None:
            self._values["auth_url"] = auth_url
        if cacert_file is not None:
            self._values["cacert_file"] = cacert_file
        if cert is not None:
            self._values["cert"] = cert
        if cloud is not None:
            self._values["cloud"] = cloud
        if default_domain is not None:
            self._values["default_domain"] = default_domain
        if domain_id is not None:
            self._values["domain_id"] = domain_id
        if domain_name is not None:
            self._values["domain_name"] = domain_name
        if expire_after is not None:
            self._values["expire_after"] = expire_after
        if insecure is not None:
            self._values["insecure"] = insecure
        if key is not None:
            self._values["key"] = key
        if password is not None:
            self._values["password"] = password
        if project_domain_id is not None:
            self._values["project_domain_id"] = project_domain_id
        if project_domain_name is not None:
            self._values["project_domain_name"] = project_domain_name
        if region_name is not None:
            self._values["region_name"] = region_name
        if state_name is not None:
            self._values["state_name"] = state_name
        if tenant_id is not None:
            self._values["tenant_id"] = tenant_id
        if tenant_name is not None:
            self._values["tenant_name"] = tenant_name
        if token is not None:
            self._values["token"] = token
        if user_domain_id is not None:
            self._values["user_domain_id"] = user_domain_id
        if user_domain_name is not None:
            self._values["user_domain_name"] = user_domain_name
        if user_id is not None:
            self._values["user_id"] = user_id
        if user_name is not None:
            self._values["user_name"] = user_name

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@jsii.implements(ITokenResolver)
class DefaultTokenResolver(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.DefaultTokenResolver",
):
    '''(experimental) Default resolver implementation.

    :stability: experimental
    '''

    def __init__(self, concat: IFragmentConcatenator) -> None:
        '''(experimental) Resolves tokens.

        :param concat: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f2b95f794823341f37ee593434355a464d52dc6e73138e44c124fd1a153141b2)
            check_type(argname="argument concat", value=concat, expected_type=type_hints["concat"])
        jsii.create(self.__class__, self, [concat])

    @jsii.member(jsii_name="resolveList")
    def resolve_list(
        self,
        xs: typing.Sequence[builtins.str],
        context: IResolveContext,
    ) -> typing.Any:
        '''(experimental) Resolves a list of string.

        :param xs: -
        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6056680db093e603c1b0e3932d2764af0a50af14c58a9ee2660c2287b5a5409f)
            check_type(argname="argument xs", value=xs, expected_type=type_hints["xs"])
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolveList", [xs, context]))

    @jsii.member(jsii_name="resolveMap")
    def resolve_map(
        self,
        xs: typing.Mapping[builtins.str, typing.Any],
        context: IResolveContext,
    ) -> typing.Any:
        '''(experimental) Resolves a map token.

        :param xs: -
        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0a174184a30b505b73373dc6bdcb0b205a58fff873589cb4ff366f1200721203)
            check_type(argname="argument xs", value=xs, expected_type=type_hints["xs"])
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolveMap", [xs, context]))

    @jsii.member(jsii_name="resolveNumberList")
    def resolve_number_list(
        self,
        xs: typing.Sequence[jsii.Number],
        context: IResolveContext,
    ) -> typing.Any:
        '''(experimental) Resolves a list of numbers.

        :param xs: -
        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bb4c86d87df095d23f4cae1d883d72bbd2609121f17dd640369d4c182f0233e0)
            check_type(argname="argument xs", value=xs, expected_type=type_hints["xs"])
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolveNumberList", [xs, context]))

    @jsii.member(jsii_name="resolveString")
    def resolve_string(
        self,
        fragments: TokenizedStringFragments,
        context: IResolveContext,
    ) -> typing.Any:
        '''(experimental) Resolve string fragments to Tokens.

        :param fragments: -
        :param context: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__293ff48c71fb097f1077397301da72b8d62680dbed80a3af6896154e66ae21e1)
            check_type(argname="argument fragments", value=fragments, expected_type=type_hints["fragments"])
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolveString", [fragments, context]))

    @jsii.member(jsii_name="resolveToken")
    def resolve_token(
        self,
        t: IResolvable,
        context: IResolveContext,
        post_processor: IPostProcessor,
    ) -> typing.Any:
        '''(experimental) Default Token resolution.

        Resolve the Token, recurse into whatever it returns,
        then finally post-process it.

        :param t: -
        :param context: -
        :param post_processor: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__641a39ca952ea8de54da6a148deeb5cbaf15fed101307489a3338212680f2c62)
            check_type(argname="argument t", value=t, expected_type=type_hints["t"])
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
            check_type(argname="argument post_processor", value=post_processor, expected_type=type_hints["post_processor"])
        return typing.cast(typing.Any, jsii.invoke(self, "resolveToken", [t, context, post_processor]))


class Fn(FnGenerated, metaclass=jsii.JSIIMeta, jsii_type="cdktn.Fn"):
    '''
    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="bcrypt")
    @builtins.classmethod
    def bcrypt(
        cls,
        str: builtins.str,
        cost: typing.Optional[jsii.Number] = None,
    ) -> builtins.str:
        '''(experimental) {@link /terraform/docs/language/functions/bcrypt.html bcrypt} computes a hash of the given string using the Blowfish cipher, returning a string in `the *Modular Crypt Format* <https://passlib.readthedocs.io/en/stable/modular_crypt_format.html>`_ usually expected in the shadow password file on many Unix systems.

        :param str: -
        :param cost: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4c5467c68090942094aed743904a13e7fc8aec87220ee78eb0be1fec7c953667)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
            check_type(argname="argument cost", value=cost, expected_type=type_hints["cost"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "bcrypt", [str, cost]))

    @jsii.member(jsii_name="conditional")
    @builtins.classmethod
    def conditional(
        cls,
        condition: typing.Any,
        true_value: typing.Any,
        false_value: typing.Any,
    ) -> typing.Any:
        '''(experimental) {@link https://developer.hashicorp.com/terraform/language/expressions/conditionals} A conditional expression uses the value of a boolean expression to select one of two values.

        :param condition: -
        :param true_value: -
        :param false_value: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f594512f4c16c4f129b6798263de835601f32e7474def17a7a41dbe01bb86739)
            check_type(argname="argument condition", value=condition, expected_type=type_hints["condition"])
            check_type(argname="argument true_value", value=true_value, expected_type=type_hints["true_value"])
            check_type(argname="argument false_value", value=false_value, expected_type=type_hints["false_value"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "conditional", [condition, true_value, false_value]))

    @jsii.member(jsii_name="join")
    @builtins.classmethod
    def join(
        cls,
        separator: builtins.str,
        list: typing.Sequence[builtins.str],
    ) -> builtins.str:
        '''(experimental) {@link /terraform/docs/language/functions/join.html join} produces a string by concatenating together all elements of a given list of strings with the given delimiter.

        :param separator: -
        :param list: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3b9575296fdfdf297bf540cd6c330e358acd3c2746d1361e49a88b7404b6c33f)
            check_type(argname="argument separator", value=separator, expected_type=type_hints["separator"])
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "join", [separator, list]))

    @jsii.member(jsii_name="lookup")
    @builtins.classmethod
    def lookup(
        cls,
        input_map: typing.Any,
        key: builtins.str,
        default_value: typing.Any = None,
    ) -> typing.Any:
        '''(experimental) {@link /terraform/docs/language/functions/lookup.html lookup} retrieves the value of a single element from a map, given its key. If the given key does not exist, the given default value is returned instead.

        :param input_map: -
        :param key: -
        :param default_value: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d3828023e169a0e571da531e01584927c3552aebae8dc798916eab203d877fc5)
            check_type(argname="argument input_map", value=input_map, expected_type=type_hints["input_map"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
            check_type(argname="argument default_value", value=default_value, expected_type=type_hints["default_value"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "lookup", [input_map, key, default_value]))

    @jsii.member(jsii_name="lookupNested")
    @builtins.classmethod
    def lookup_nested(
        cls,
        input_map: typing.Any,
        path: typing.Sequence[typing.Any],
    ) -> typing.Any:
        '''(experimental) returns a property access expression that accesses the property at the given path in the given inputMap.

        For example lookupNested(x, ["a", "b", "c"]) will return a Terraform expression like x["a"]["b"]["c"]

        :param input_map: -
        :param path: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4ed2533a68e0c9207319a96c375f8d7b50d5b776ff4617706a5a44e80322b244)
            check_type(argname="argument input_map", value=input_map, expected_type=type_hints["input_map"])
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "lookupNested", [input_map, path]))

    @jsii.member(jsii_name="range")
    @builtins.classmethod
    def range(
        cls,
        start: jsii.Number,
        limit: jsii.Number,
        step: typing.Optional[jsii.Number] = None,
    ) -> typing.List[builtins.str]:
        '''(experimental) {@link /terraform/docs/language/functions/range.html range} generates a list of numbers using a start value, a limit value, and a step value.

        :param start: -
        :param limit: -
        :param step: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bc7a76fbacde6913f9a72019b61a4c1a13eaff40f9a294ea7bdceb45ef865d52)
            check_type(argname="argument start", value=start, expected_type=type_hints["start"])
            check_type(argname="argument limit", value=limit, expected_type=type_hints["limit"])
            check_type(argname="argument step", value=step, expected_type=type_hints["step"])
        return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "range", [start, limit, step]))

    @jsii.member(jsii_name="rawString")
    @builtins.classmethod
    def raw_string(cls, str: builtins.str) -> builtins.str:
        '''(experimental) Use this function to wrap a string and escape it properly for the use in Terraform This is only needed in certain scenarios (e.g., if you have unescaped double quotes in the string).

        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__11546960bc932f2fcfb3274bdef00a66c7ad3e80c4ce09cb45e997ae666d10cf)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "rawString", [str]))


class ImportableResource(
    TerraformElement,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.ImportableResource",
):
    '''(experimental) Class used to represent an importable resource.

    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        name: builtins.str,
        config: IImportableConfig,
    ) -> None:
        '''
        :param scope: -
        :param name: -
        :param config: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3a864fc54f2ce1cec2cac2d50edf70b1efc0d97c5d4361ce4ade3531f0e6bd1b)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument config", value=config, expected_type=type_hints["config"])
        jsii.create(self.__class__, self, [scope, name, config])

    @jsii.member(jsii_name="toHclTerraform")
    def to_hcl_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toHclTerraform", []))

    @jsii.member(jsii_name="toMetadata")
    def to_metadata(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toMetadata", []))

    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toTerraform", []))


class ListTerraformIterator(
    TerraformIterator,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.ListTerraformIterator",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        list: typing.Union[typing.Sequence[builtins.str], IResolvable, typing.Sequence[jsii.Number], typing.Sequence[typing.Union[builtins.bool, IResolvable]]],
    ) -> None:
        '''
        :param list: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bff9577b80efe93cd92790ad069033a88b86c00ba3e3c61f1c9d94dc2c180114)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
        jsii.create(self.__class__, self, [list])

    @builtins.property
    @jsii.member(jsii_name="key")
    def key(self) -> typing.Any:
        '''(experimental) Returns the currently entry in the list or set that is being iterated over.

        For lists this is the same as ``iterator.value``. If you need the index,
        use count via ``TerraformCount``:
        https://developer.hashicorp.com/terraform/cdktf/concepts/iterators#using-count

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.get(self, "key"))

    @builtins.property
    @jsii.member(jsii_name="value")
    def value(self) -> typing.Any:
        '''(experimental) Returns the value of the current item iterated over.

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.get(self, "value"))


class MapTerraformIterator(
    TerraformIterator,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.MapTerraformIterator",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        map: typing.Union[AnyMap, StringMap, NumberMap, BooleanMap, ComplexMap, typing.Mapping[builtins.str, typing.Any], typing.Mapping[builtins.str, builtins.str], typing.Mapping[builtins.str, jsii.Number]],
    ) -> None:
        '''
        :param map: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ce20ad81cfc28b15ef4f724cb63097e918f91423285c83d986a3f4b36c716567)
            check_type(argname="argument map", value=map, expected_type=type_hints["map"])
        jsii.create(self.__class__, self, [map])

    @builtins.property
    @jsii.member(jsii_name="key")
    def key(self) -> builtins.str:
        '''(experimental) Returns the key of the current entry in the map that is being iterated over.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "key"))

    @builtins.property
    @jsii.member(jsii_name="value")
    def value(self) -> typing.Any:
        '''(experimental) Returns the value of the current item iterated over.

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.get(self, "value"))


class NumberListList(
    ComplexList,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.NumberListList",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
        wraps_set: builtins.bool,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -
        :param wraps_set: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__377e1e40d4a4fed37cb40fd6c5e353a99401c62c637d0b507bbdc6ad75ba8c1b)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
            check_type(argname="argument wraps_set", value=wraps_set, expected_type=type_hints["wraps_set"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute, wraps_set])

    @jsii.member(jsii_name="get")
    def get(self, index: jsii.Number) -> typing.List[jsii.Number]:
        '''
        :param index: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__587933ef9ec3abf46e938de00d234a7e733434ed884b519c4344be128489102a)
            check_type(argname="argument index", value=index, expected_type=type_hints["index"])
        return typing.cast(typing.List[jsii.Number], jsii.invoke(self, "get", [index]))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dca8031678e7b6a525b55a3ef0788752abf13bc39fd7ee072ba68b169cd25737)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__29d505b0c1d642210eee22317dfbf8e0585ac9e68fc5462ebebb78b9305ef174)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="wrapsSet")
    def _wraps_set(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "wrapsSet"))

    @_wraps_set.setter
    def _wraps_set(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4602c433f12bb554b396c6abd6c505833ef3a9e9cd23d2728c2b92a87230be44)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "wrapsSet", value) # pyright: ignore[reportArgumentType]


class NumberListMap(
    ComplexMap,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.NumberListMap",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3dfcebae9c364365fcc06a8c4600122becd1dac9da575e3787caaf385b60f00f)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute])

    @jsii.member(jsii_name="get")
    def get(self, key: builtins.str) -> typing.List[jsii.Number]:
        '''
        :param key: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4191dc02df325a1cd5de482d5a8f21e4770e2507ab7ea6d881b1d96b7fd910e1)
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
        return typing.cast(typing.List[jsii.Number], jsii.invoke(self, "get", [key]))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__02d86949bb07afc18faccf3fb4b65c2e92b378b87e2897811fb2653b3f40c116)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2226bdf009964e1e76d0abd38167c0b3b45fc6d84c6cf0000b799d467b3d49e3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]


@jsii.data_type(
    jsii_type="cdktn.Postcondition",
    jsii_struct_bases=[TerraformCondition],
    name_mapping={"condition": "condition", "error_message": "errorMessage"},
)
class Postcondition(TerraformCondition):
    def __init__(self, *, condition: typing.Any, error_message: builtins.str) -> None:
        '''(experimental) Terraform checks a postcondition after evaluating the object it is associated with.

        :param condition: (experimental) This is a boolean expression that should return true if the intended assumption or guarantee is fulfilled or false if it does not.
        :param error_message: (experimental) This contains the text that Terraform will include as part of error messages when it detects an unmet condition.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e711777cba24fbe9d48a70e7c4344d7b32b0f81a58f544e556de4a4ebee968be)
            check_type(argname="argument condition", value=condition, expected_type=type_hints["condition"])
            check_type(argname="argument error_message", value=error_message, expected_type=type_hints["error_message"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "condition": condition,
            "error_message": error_message,
        }

    @builtins.property
    def condition(self) -> typing.Any:
        '''(experimental) This is a boolean expression that should return true if the intended assumption or guarantee is fulfilled or false if it does not.

        :stability: experimental
        '''
        result = self._values.get("condition")
        assert result is not None, "Required property 'condition' is missing"
        return typing.cast(typing.Any, result)

    @builtins.property
    def error_message(self) -> builtins.str:
        '''(experimental) This contains the text that Terraform will include as part of error messages when it detects an unmet condition.

        :stability: experimental
        '''
        result = self._values.get("error_message")
        assert result is not None, "Required property 'error_message' 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 "Postcondition(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdktn.Precondition",
    jsii_struct_bases=[TerraformCondition],
    name_mapping={"condition": "condition", "error_message": "errorMessage"},
)
class Precondition(TerraformCondition):
    def __init__(self, *, condition: typing.Any, error_message: builtins.str) -> None:
        '''(experimental) Terraform checks a precondition before evaluating the object it is associated with.

        :param condition: (experimental) This is a boolean expression that should return true if the intended assumption or guarantee is fulfilled or false if it does not.
        :param error_message: (experimental) This contains the text that Terraform will include as part of error messages when it detects an unmet condition.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__611700f74474891eb1702fbbf4894fd2f0577b14f763d6b28a068023d836979a)
            check_type(argname="argument condition", value=condition, expected_type=type_hints["condition"])
            check_type(argname="argument error_message", value=error_message, expected_type=type_hints["error_message"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "condition": condition,
            "error_message": error_message,
        }

    @builtins.property
    def condition(self) -> typing.Any:
        '''(experimental) This is a boolean expression that should return true if the intended assumption or guarantee is fulfilled or false if it does not.

        :stability: experimental
        '''
        result = self._values.get("condition")
        assert result is not None, "Required property 'condition' is missing"
        return typing.cast(typing.Any, result)

    @builtins.property
    def error_message(self) -> builtins.str:
        '''(experimental) This contains the text that Terraform will include as part of error messages when it detects an unmet condition.

        :stability: experimental
        '''
        result = self._values.get("error_message")
        assert result is not None, "Required property 'error_message' 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 "Precondition(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class ResourceTerraformIterator(
    TerraformIterator,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.ResourceTerraformIterator",
):
    '''
    :stability: experimental
    '''

    def __init__(self, element: ITerraformResource) -> None:
        '''
        :param element: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d856fa24b334264240bb244284b70a4b13dbefb2734f92650a3c9f0fe05adfc4)
            check_type(argname="argument element", value=element, expected_type=type_hints["element"])
        jsii.create(self.__class__, self, [element])

    @builtins.property
    @jsii.member(jsii_name="key")
    def key(self) -> typing.Any:
        '''(experimental) Returns the current entry in the list or set that is being iterated over.

        For lists this is the same as ``iterator.value``. If you need the index,
        use count via ``TerraformCount``:
        https://developer.hashicorp.com/terraform/cdktf/concepts/iterators#using-count

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.get(self, "key"))

    @builtins.property
    @jsii.member(jsii_name="value")
    def value(self) -> typing.Any:
        '''(experimental) Returns the value of the current item iterated over.

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.get(self, "value"))


class StringListList(
    ComplexList,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.StringListList",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
        wraps_set: builtins.bool,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -
        :param wraps_set: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ae639d57097f43a3aa82fd8387b52e259b8e5469a6ab1815c83b9842a34d65f2)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
            check_type(argname="argument wraps_set", value=wraps_set, expected_type=type_hints["wraps_set"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute, wraps_set])

    @jsii.member(jsii_name="get")
    def get(self, index: jsii.Number) -> typing.List[builtins.str]:
        '''
        :param index: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__83ed1169b003bcfcd74fd0466801bbdb1b39de5a53b1b6294fbfdc143bbbe83d)
            check_type(argname="argument index", value=index, expected_type=type_hints["index"])
        return typing.cast(typing.List[builtins.str], jsii.invoke(self, "get", [index]))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3262e351c3df9b2e3cabdb7c8866c967ecc79f713eebaefcb3f1fb8ec7d02e80)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bf26a6f7b34e9a17032a5106604e633317996d42186dbcb1edd82c6074f1e70b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="wrapsSet")
    def _wraps_set(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "wrapsSet"))

    @_wraps_set.setter
    def _wraps_set(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e0743f08909faee723dd22da5a98fd5ad349f81069ff8673d6e661c8422cd685)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "wrapsSet", value) # pyright: ignore[reportArgumentType]


class StringListMap(
    ComplexMap,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.StringListMap",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fbd1f72f72ea827f8a1bbb28d195f94def6676fb5338faf323f59651be1ec6f2)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute])

    @jsii.member(jsii_name="get")
    def get(self, key: builtins.str) -> typing.List[builtins.str]:
        '''
        :param key: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__88639fa3567a45f74f15045d201cc02fd4a435f6097671fa23704973087001d8)
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
        return typing.cast(typing.List[builtins.str], jsii.invoke(self, "get", [key]))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__761654b3bc050b012a9a946ba6427b88e131a1e323fa372e31a9164bc790789b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d77b6e7699a39ba03848e76ac4a00208ab5e8c8bc1ba7dc9dfc4b947482945f1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]


class TerraformBackend(
    TerraformElement,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="cdktn.TerraformBackend",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        name: builtins.str,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9879ecc912d8d803dd95efd3bcbd6377f8ba3395f5a3e76fb06594c51f2a3385)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
        jsii.create(self.__class__, self, [scope, id, name])

    @jsii.member(jsii_name="isBackend")
    @builtins.classmethod
    def is_backend(cls, x: typing.Any) -> builtins.bool:
        '''
        :param x: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__76aae6fdf466efc66fd849a25cd46a145beee041c98fbc2b41220a3fcbd9d092)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "isBackend", [x]))

    @jsii.member(jsii_name="getRemoteStateDataSource")
    @abc.abstractmethod
    def get_remote_state_data_source(
        self,
        scope: _constructs_77d1e7e8.Construct,
        name: builtins.str,
        from_stack: builtins.str,
    ) -> TerraformRemoteState:
        '''(experimental) Creates a TerraformRemoteState resource that accesses this backend.

        :param scope: -
        :param name: -
        :param from_stack: -

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))

    @jsii.member(jsii_name="toHclTerraform")
    def to_hcl_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toHclTerraform", []))

    @jsii.member(jsii_name="toMetadata")
    def to_metadata(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toMetadata", []))

    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> typing.Any:
        '''(experimental) Adds this resource to the terraform JSON output.

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toTerraform", []))

    @builtins.property
    @jsii.member(jsii_name="name")
    def _name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "name"))


class _TerraformBackendProxy(TerraformBackend):
    @jsii.member(jsii_name="getRemoteStateDataSource")
    def get_remote_state_data_source(
        self,
        scope: _constructs_77d1e7e8.Construct,
        name: builtins.str,
        from_stack: builtins.str,
    ) -> TerraformRemoteState:
        '''(experimental) Creates a TerraformRemoteState resource that accesses this backend.

        :param scope: -
        :param name: -
        :param from_stack: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b69861f032db45a9e14cf4f04bc733facf9e92cdafbe666c9737ea2fae5a3acf)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument from_stack", value=from_stack, expected_type=type_hints["from_stack"])
        return typing.cast(TerraformRemoteState, jsii.invoke(self, "getRemoteStateDataSource", [scope, name, from_stack]))

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


@jsii.implements(ITerraformResource, ITerraformDependable, IInterpolatingParent)
class TerraformDataSource(
    TerraformElement,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.TerraformDataSource",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        terraform_resource_type: builtins.str,
        terraform_generator_metadata: typing.Optional[typing.Union[TerraformProviderGeneratorMetadata, typing.Dict[builtins.str, typing.Any]]] = None,
        connection: typing.Optional[typing.Union[typing.Union[SSHProvisionerConnection, typing.Dict[builtins.str, typing.Any]], typing.Union[WinrmProvisionerConnection, typing.Dict[builtins.str, typing.Any]]]] = None,
        count: typing.Optional[typing.Union[jsii.Number, TerraformCount]] = None,
        depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
        for_each: typing.Optional[ITerraformIterator] = None,
        lifecycle: typing.Optional[typing.Union[TerraformResourceLifecycle, typing.Dict[builtins.str, typing.Any]]] = None,
        provider: typing.Optional[TerraformProvider] = None,
        provisioners: typing.Optional[typing.Sequence[typing.Union[typing.Union[FileProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[LocalExecProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[RemoteExecProvisioner, typing.Dict[builtins.str, typing.Any]]]]] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param terraform_resource_type: 
        :param terraform_generator_metadata: 
        :param connection: 
        :param count: 
        :param depends_on: 
        :param for_each: 
        :param lifecycle: 
        :param provider: 
        :param provisioners: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__79e70c02e316a3d97b837eb6fc8e7fe114471049fcb998f605f6bbd388988a79)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        config = TerraformResourceConfig(
            terraform_resource_type=terraform_resource_type,
            terraform_generator_metadata=terraform_generator_metadata,
            connection=connection,
            count=count,
            depends_on=depends_on,
            for_each=for_each,
            lifecycle=lifecycle,
            provider=provider,
            provisioners=provisioners,
        )

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

    @jsii.member(jsii_name="isTerraformDataSource")
    @builtins.classmethod
    def is_terraform_data_source(cls, x: typing.Any) -> builtins.bool:
        '''
        :param x: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a1b28d14493d7002b4cbf3fb3200b1225371de6afb8c6c0d521d64d6caae5a43)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "isTerraformDataSource", [x]))

    @jsii.member(jsii_name="getAnyMapAttribute")
    def get_any_map_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e3aadb8603d69b1252968369f03f73ae0ae285de3341bacf20b420f020b74ae0)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "getAnyMapAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getBooleanAttribute")
    def get_boolean_attribute(self, terraform_attribute: builtins.str) -> IResolvable:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__72e402c22d93cc64951981cc59d074d4972a28f38e112fe67f57a2dfe6173895)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(IResolvable, jsii.invoke(self, "getBooleanAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getBooleanMapAttribute")
    def get_boolean_map_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, builtins.bool]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1903b7e4c4a8eb893dff56555f1d3636c378991f9d55c4ea6022f471cf9de6ec)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.Mapping[builtins.str, builtins.bool], jsii.invoke(self, "getBooleanMapAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getListAttribute")
    def get_list_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.List[builtins.str]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8610d6b4dbf4720db1ce4a8f76e7044ecb4d9da9e756a301f7642157fb68b530)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.List[builtins.str], jsii.invoke(self, "getListAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getNumberAttribute")
    def get_number_attribute(self, terraform_attribute: builtins.str) -> jsii.Number:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__953ceb45ca32c1274a54558856520d318eabc6c55016c8b78ac494636fa6e373)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(jsii.Number, jsii.invoke(self, "getNumberAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getNumberListAttribute")
    def get_number_list_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.List[jsii.Number]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ab1fc6f672aef943e94cc5a054f2d5fcb5e8eb539cf737a33f58e80366c34975)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.List[jsii.Number], jsii.invoke(self, "getNumberListAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getNumberMapAttribute")
    def get_number_map_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, jsii.Number]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a0a08217c9d7a9e852d50eee4bcf8d318835565a8bed962874c7e4d8bbfbbfdc)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.Mapping[builtins.str, jsii.Number], jsii.invoke(self, "getNumberMapAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getStringAttribute")
    def get_string_attribute(self, terraform_attribute: builtins.str) -> builtins.str:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__41eb4eb085b596cf5ccb672a093ae636054480e7da7ee0cbf39869feea8d91fc)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(builtins.str, jsii.invoke(self, "getStringAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="getStringMapAttribute")
    def get_string_map_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0b0436b711dcd2720449fcbe0743723e5b49162694730be5db99186922b5230c)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.invoke(self, "getStringMapAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="interpolationForAttribute")
    def interpolation_for_attribute(
        self,
        terraform_attribute: builtins.str,
    ) -> IResolvable:
        '''
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b4b3a8be61d403c79cedc8d9016b87795d0b3c18bf603dbc0c8a3d3ee2b6f6ff)
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        return typing.cast(IResolvable, jsii.invoke(self, "interpolationForAttribute", [terraform_attribute]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))

    @jsii.member(jsii_name="toHclTerraform")
    def to_hcl_terraform(self) -> typing.Any:
        '''(experimental) Adds this resource to the terraform JSON output.

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toHclTerraform", []))

    @jsii.member(jsii_name="toMetadata")
    def to_metadata(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toMetadata", []))

    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> typing.Any:
        '''(experimental) Adds this resource to the terraform JSON output.

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toTerraform", []))

    @builtins.property
    @jsii.member(jsii_name="terraformMetaArguments")
    def terraform_meta_arguments(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "terraformMetaArguments"))

    @builtins.property
    @jsii.member(jsii_name="terraformResourceType")
    def terraform_resource_type(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformResourceType"))

    @builtins.property
    @jsii.member(jsii_name="terraformGeneratorMetadata")
    def terraform_generator_metadata(
        self,
    ) -> typing.Optional[TerraformProviderGeneratorMetadata]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[TerraformProviderGeneratorMetadata], jsii.get(self, "terraformGeneratorMetadata"))

    @builtins.property
    @jsii.member(jsii_name="count")
    def count(self) -> typing.Optional[typing.Union[jsii.Number, TerraformCount]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[jsii.Number, TerraformCount]], jsii.get(self, "count"))

    @count.setter
    def count(
        self,
        value: typing.Optional[typing.Union[jsii.Number, TerraformCount]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2f94c678891e12174637ccbff2e0d9e5411b027282b4e021329fa621bac347f0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "count", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="dependsOn")
    def depends_on(self) -> typing.Optional[typing.List[builtins.str]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "dependsOn"))

    @depends_on.setter
    def depends_on(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3b9d0c3a86c4a4515dd26cb231487a18a4b57a0c97a2e27b0257fb626ec827f2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "dependsOn", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="forEach")
    def for_each(self) -> typing.Optional[ITerraformIterator]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[ITerraformIterator], jsii.get(self, "forEach"))

    @for_each.setter
    def for_each(self, value: typing.Optional[ITerraformIterator]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__79ddad63cdda152ee46a947839bcc90e4bc338b45dac19bd676cd9c54928e9a2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "forEach", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="lifecycle")
    def lifecycle(self) -> typing.Optional[TerraformResourceLifecycle]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[TerraformResourceLifecycle], jsii.get(self, "lifecycle"))

    @lifecycle.setter
    def lifecycle(self, value: typing.Optional[TerraformResourceLifecycle]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__de278fe900c1b77867b14d06decdd63b05d5bf4e4c5383bcdcbbf74185da1f28)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "lifecycle", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="provider")
    def provider(self) -> typing.Optional[TerraformProvider]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[TerraformProvider], jsii.get(self, "provider"))

    @provider.setter
    def provider(self, value: typing.Optional[TerraformProvider]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8c7725e4968fe71a08ab51f1e6768295ade0c979611cce6fa8d80d5367bb70ce)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "provider", value) # pyright: ignore[reportArgumentType]


class TerraformHclModule(
    TerraformModule,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.TerraformHclModule",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        variables: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        source: builtins.str,
        version: typing.Optional[builtins.str] = None,
        depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
        for_each: typing.Optional[ITerraformIterator] = None,
        providers: typing.Optional[typing.Sequence[typing.Union[TerraformProvider, typing.Union[TerraformModuleProvider, typing.Dict[builtins.str, typing.Any]]]]] = None,
        skip_asset_creation_from_local_modules: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param variables: 
        :param source: 
        :param version: 
        :param depends_on: 
        :param for_each: 
        :param providers: 
        :param skip_asset_creation_from_local_modules: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__466cfc82d7fca4a515dce43e5e24509317c734e84d3d8c951224b8805ea2a9b9)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = TerraformHclModuleConfig(
            variables=variables,
            source=source,
            version=version,
            depends_on=depends_on,
            for_each=for_each,
            providers=providers,
            skip_asset_creation_from_local_modules=skip_asset_creation_from_local_modules,
        )

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

    @jsii.member(jsii_name="get")
    def get(self, output: builtins.str) -> typing.Any:
        '''
        :param output: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__529096037264e016a830fc477cda4eb547ad98ee919a8483da9cb0148256c23b)
            check_type(argname="argument output", value=output, expected_type=type_hints["output"])
        return typing.cast(typing.Any, jsii.invoke(self, "get", [output]))

    @jsii.member(jsii_name="getBoolean")
    def get_boolean(self, output: builtins.str) -> IResolvable:
        '''
        :param output: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6cae949c476103db1aec038992f221f24f126dad6b3309dd40ad7f02397f2c24)
            check_type(argname="argument output", value=output, expected_type=type_hints["output"])
        return typing.cast(IResolvable, jsii.invoke(self, "getBoolean", [output]))

    @jsii.member(jsii_name="getList")
    def get_list(self, output: builtins.str) -> typing.List[builtins.str]:
        '''
        :param output: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f9ce234005522f28e3659b04bca2d75f815ee2e59049e7728af8731bc5c4fe92)
            check_type(argname="argument output", value=output, expected_type=type_hints["output"])
        return typing.cast(typing.List[builtins.str], jsii.invoke(self, "getList", [output]))

    @jsii.member(jsii_name="getNumber")
    def get_number(self, output: builtins.str) -> jsii.Number:
        '''
        :param output: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__57bb37279f18e7b2760743d39dd2c48755e9c5a1c77e84ddb508258e9811ed88)
            check_type(argname="argument output", value=output, expected_type=type_hints["output"])
        return typing.cast(jsii.Number, jsii.invoke(self, "getNumber", [output]))

    @jsii.member(jsii_name="set")
    def set(self, variable: builtins.str, value: typing.Any) -> None:
        '''
        :param variable: -
        :param value: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__65438d4d11b541ac2ac28ec8857f5d0c3963e984384da07c6f33fba392cdaa77)
            check_type(argname="argument variable", value=variable, expected_type=type_hints["variable"])
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        return typing.cast(None, jsii.invoke(self, "set", [variable, value]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))

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


@jsii.data_type(
    jsii_type="cdktn.TerraformModuleConfig",
    jsii_struct_bases=[TerraformModuleUserConfig],
    name_mapping={
        "depends_on": "dependsOn",
        "for_each": "forEach",
        "providers": "providers",
        "skip_asset_creation_from_local_modules": "skipAssetCreationFromLocalModules",
        "source": "source",
        "version": "version",
    },
)
class TerraformModuleConfig(TerraformModuleUserConfig):
    def __init__(
        self,
        *,
        depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
        for_each: typing.Optional[ITerraformIterator] = None,
        providers: typing.Optional[typing.Sequence[typing.Union[TerraformProvider, typing.Union[TerraformModuleProvider, typing.Dict[builtins.str, typing.Any]]]]] = None,
        skip_asset_creation_from_local_modules: typing.Optional[builtins.bool] = None,
        source: builtins.str,
        version: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param depends_on: 
        :param for_each: 
        :param providers: 
        :param skip_asset_creation_from_local_modules: 
        :param source: 
        :param version: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__060d43cd671b2ad8af16570ac8f9c32edd5be5e6966211fa28fc0bd314d330fd)
            check_type(argname="argument depends_on", value=depends_on, expected_type=type_hints["depends_on"])
            check_type(argname="argument for_each", value=for_each, expected_type=type_hints["for_each"])
            check_type(argname="argument providers", value=providers, expected_type=type_hints["providers"])
            check_type(argname="argument skip_asset_creation_from_local_modules", value=skip_asset_creation_from_local_modules, expected_type=type_hints["skip_asset_creation_from_local_modules"])
            check_type(argname="argument source", value=source, expected_type=type_hints["source"])
            check_type(argname="argument version", value=version, expected_type=type_hints["version"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "source": source,
        }
        if depends_on is not None:
            self._values["depends_on"] = depends_on
        if for_each is not None:
            self._values["for_each"] = for_each
        if providers is not None:
            self._values["providers"] = providers
        if skip_asset_creation_from_local_modules is not None:
            self._values["skip_asset_creation_from_local_modules"] = skip_asset_creation_from_local_modules
        if version is not None:
            self._values["version"] = version

    @builtins.property
    def depends_on(self) -> typing.Optional[typing.List[ITerraformDependable]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("depends_on")
        return typing.cast(typing.Optional[typing.List[ITerraformDependable]], result)

    @builtins.property
    def for_each(self) -> typing.Optional[ITerraformIterator]:
        '''
        :stability: experimental
        '''
        result = self._values.get("for_each")
        return typing.cast(typing.Optional[ITerraformIterator], result)

    @builtins.property
    def providers(
        self,
    ) -> typing.Optional[typing.List[typing.Union[TerraformProvider, TerraformModuleProvider]]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("providers")
        return typing.cast(typing.Optional[typing.List[typing.Union[TerraformProvider, TerraformModuleProvider]]], result)

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

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

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


class AnyListList(ComplexList, metaclass=jsii.JSIIMeta, jsii_type="cdktn.AnyListList"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
        wraps_set: builtins.bool,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -
        :param wraps_set: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6f4ca4759408d158b9485d1098c340519c34813b84b68c06e0a1710d1dca7ca7)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
            check_type(argname="argument wraps_set", value=wraps_set, expected_type=type_hints["wraps_set"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute, wraps_set])

    @jsii.member(jsii_name="get")
    def get(self, index: jsii.Number) -> IResolvable:
        '''
        :param index: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9038dfad752950d49aff530ab1782b12dfb04b228005231d25abd071e86ad3ff)
            check_type(argname="argument index", value=index, expected_type=type_hints["index"])
        return typing.cast(IResolvable, jsii.invoke(self, "get", [index]))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__558ce7ae53772463e2f910529fddaafde0cbb35e082aaec76781d6f2167b3419)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ee63ab762f58cc6485232a7fc8d16c1cca04b991ed8b1f4945682d390f69ebc7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="wrapsSet")
    def _wraps_set(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "wrapsSet"))

    @_wraps_set.setter
    def _wraps_set(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__201e67cd7c4a3f034bf7506954ea6c520c81cd984d6543f19721117114c785cc)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "wrapsSet", value) # pyright: ignore[reportArgumentType]


class AnyListMap(ComplexMap, metaclass=jsii.JSIIMeta, jsii_type="cdktn.AnyListMap"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e731091bb1fcfdf5e69f850a305db13376224296ce6d172d5eaeedffef25f8a1)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute])

    @jsii.member(jsii_name="get")
    def get(self, key: builtins.str) -> IResolvable:
        '''
        :param key: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__36a4b33a9f788a649f400dcf834d576d64b0f9f67c65ff0ff761bab864d2b157)
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
        return typing.cast(IResolvable, jsii.invoke(self, "get", [key]))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9f117a8b982ec5c4a0e3c53af5e0c4ff990dfcd669a4612cb005fd631e9ab4be)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__785dddd5038aecc05961a11a534a022cd8a0138bef1a49af1ca1365e65fc2d86)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]


class AzurermBackend(
    TerraformBackend,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.AzurermBackend",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        *,
        container_name: builtins.str,
        key: builtins.str,
        storage_account_name: builtins.str,
        access_key: typing.Optional[builtins.str] = None,
        client_certificate_password: typing.Optional[builtins.str] = None,
        client_certificate_path: typing.Optional[builtins.str] = None,
        client_id: typing.Optional[builtins.str] = None,
        client_secret: typing.Optional[builtins.str] = None,
        endpoint: typing.Optional[builtins.str] = None,
        environment: typing.Optional[builtins.str] = None,
        metadata_host: typing.Optional[builtins.str] = None,
        msi_endpoint: typing.Optional[builtins.str] = None,
        oidc_request_token: typing.Optional[builtins.str] = None,
        oidc_request_url: typing.Optional[builtins.str] = None,
        oidc_token: typing.Optional[builtins.str] = None,
        oidc_token_file_path: typing.Optional[builtins.str] = None,
        resource_group_name: typing.Optional[builtins.str] = None,
        sas_token: typing.Optional[builtins.str] = None,
        snapshot: typing.Optional[builtins.bool] = None,
        subscription_id: typing.Optional[builtins.str] = None,
        tenant_id: typing.Optional[builtins.str] = None,
        use_azuread_auth: typing.Optional[builtins.bool] = None,
        use_microsoft_graph: typing.Optional[builtins.bool] = None,
        use_msi: typing.Optional[builtins.bool] = None,
        use_oidc: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param container_name: (experimental) (Required) The Name of the Storage Container within the Storage Account.
        :param key: (experimental) (Required) The name of the Blob used to retrieve/store Terraform's State file inside the Storage Container.
        :param storage_account_name: (experimental) (Required) The Name of the Storage Account.
        :param access_key: (experimental) access_key - (Optional) The Access Key used to access the Blob Storage Account. This can also be sourced from the ARM_ACCESS_KEY environment variable.
        :param client_certificate_password: (experimental) (Optional) The password associated with the Client Certificate specified in client_certificate_path. This can also be sourced from the ARM_CLIENT_CERTIFICATE_PASSWORD environment variable.
        :param client_certificate_path: (experimental) (Optional) The path to the PFX file used as the Client Certificate when authenticating as a Service Principal. This can also be sourced from the ARM_CLIENT_CERTIFICATE_PATH environment variable.
        :param client_id: (experimental) (Optional) The Client ID of the Service Principal. This can also be sourced from the ARM_CLIENT_ID environment variable.
        :param client_secret: (experimental) (Optional) The Client Secret of the Service Principal. This can also be sourced from the ARM_CLIENT_SECRET environment variable.
        :param endpoint: (experimental) (Optional) The Custom Endpoint for Azure Resource Manager. This can also be sourced from the ARM_ENDPOINT environment variable. NOTE: An endpoint should only be configured when using Azure Stack.
        :param environment: (experimental) (Optional) The Azure Environment which should be used. This can also be sourced from the ARM_ENVIRONMENT environment variable. Possible values are public, china, german, stack and usgovernment. Defaults to public.
        :param metadata_host: (experimental) (Optional) The Hostname of the Azure Metadata Service (for example management.azure.com), used to obtain the Cloud Environment when using a Custom Azure Environment. This can also be sourced from the ARM_METADATA_HOSTNAME Environment Variable.).
        :param msi_endpoint: (experimental) (Optional) The path to a custom Managed Service Identity endpoint which is automatically determined if not specified. This can also be sourced from the ARM_MSI_ENDPOINT environment variable.
        :param oidc_request_token: (experimental) (Optional) The bearer token for the request to the OIDC provider. This can also be sourced from the ARM_OIDC_REQUEST_TOKEN or ACTIONS_ID_TOKEN_REQUEST_TOKEN environment variables.
        :param oidc_request_url: (experimental) (Optional) The URL for the OIDC provider from which to request an ID token. This can also be sourced from the ARM_OIDC_REQUEST_URL or ACTIONS_ID_TOKEN_REQUEST_URL environment variables.
        :param oidc_token: (experimental) (Optional) The ID token when authenticating using OpenID Connect (OIDC). This can also be sourced from the ARM_OIDC_TOKEN environment variable.
        :param oidc_token_file_path: (experimental) (Optional) The path to a file containing an ID token when authenticating using OpenID Connect (OIDC). This can also be sourced from the ARM_OIDC_TOKEN_FILE_PATH environment variable.
        :param resource_group_name: (experimental) (Required) The Name of the Resource Group in which the Storage Account exists.
        :param sas_token: (experimental) (Optional) The SAS Token used to access the Blob Storage Account. This can also be sourced from the ARM_SAS_TOKEN environment variable.
        :param snapshot: (experimental) (Optional) Should the Blob used to store the Terraform Statefile be snapshotted before use? Defaults to false. This value can also be sourced from the ARM_SNAPSHOT environment variable.
        :param subscription_id: (experimental) (Optional) The Subscription ID in which the Storage Account exists. This can also be sourced from the ARM_SUBSCRIPTION_ID environment variable.
        :param tenant_id: (experimental) (Optional) The Tenant ID in which the Subscription exists. This can also be sourced from the ARM_TENANT_ID environment variable.
        :param use_azuread_auth: (experimental) (Optional) Should AzureAD Authentication be used to access the Blob Storage Account. This can also be sourced from the ARM_USE_AZUREAD environment variable. Note: When using AzureAD for Authentication to Storage you also need to ensure the Storage Blob Data Owner role is assigned.
        :param use_microsoft_graph: (experimental) (Optional) Should MSAL be used for authentication instead of ADAL, and should Microsoft Graph be used instead of Azure Active Directory Graph? Defaults to true. Note: In Terraform 1.2 the Azure Backend uses MSAL (and Microsoft Graph) rather than ADAL (and Azure Active Directory Graph) for authentication by default - you can disable this by setting use_microsoft_graph to false. This setting will be removed in Terraform 1.3, due to Microsoft's deprecation of ADAL.
        :param use_msi: (experimental) (Optional) Should Managed Service Identity authentication be used? This can also be sourced from the ARM_USE_MSI environment variable.
        :param use_oidc: (experimental) (Optional) Should OIDC authentication be used? This can also be sourced from the ARM_USE_OIDC environment variable. Note: When using OIDC for authentication, use_microsoft_graph must be set to true (which is the default).

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d6bdabbc74cd7644b44c60771411e4c9df4352dceaada69796b967eba897eabd)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = AzurermBackendConfig(
            container_name=container_name,
            key=key,
            storage_account_name=storage_account_name,
            access_key=access_key,
            client_certificate_password=client_certificate_password,
            client_certificate_path=client_certificate_path,
            client_id=client_id,
            client_secret=client_secret,
            endpoint=endpoint,
            environment=environment,
            metadata_host=metadata_host,
            msi_endpoint=msi_endpoint,
            oidc_request_token=oidc_request_token,
            oidc_request_url=oidc_request_url,
            oidc_token=oidc_token,
            oidc_token_file_path=oidc_token_file_path,
            resource_group_name=resource_group_name,
            sas_token=sas_token,
            snapshot=snapshot,
            subscription_id=subscription_id,
            tenant_id=tenant_id,
            use_azuread_auth=use_azuread_auth,
            use_microsoft_graph=use_microsoft_graph,
            use_msi=use_msi,
            use_oidc=use_oidc,
        )

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

    @jsii.member(jsii_name="getRemoteStateDataSource")
    def get_remote_state_data_source(
        self,
        scope: _constructs_77d1e7e8.Construct,
        name: builtins.str,
        _from_stack: builtins.str,
    ) -> TerraformRemoteState:
        '''(experimental) Creates a TerraformRemoteState resource that accesses this backend.

        :param scope: -
        :param name: -
        :param _from_stack: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c9650934422e67d1a4beb014a27383daa675f0830ba5fd25b1b0881ef460d255)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument _from_stack", value=_from_stack, expected_type=type_hints["_from_stack"])
        return typing.cast(TerraformRemoteState, jsii.invoke(self, "getRemoteStateDataSource", [scope, name, _from_stack]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))


class BooleanList(ComplexList, metaclass=jsii.JSIIMeta, jsii_type="cdktn.BooleanList"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
        wraps_set: builtins.bool,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -
        :param wraps_set: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b9646960348a554bad8e6b9c1693d4e35a2223d9f87506aead823c421ad64418)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
            check_type(argname="argument wraps_set", value=wraps_set, expected_type=type_hints["wraps_set"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute, wraps_set])

    @jsii.member(jsii_name="get")
    def get(self, index: jsii.Number) -> IResolvable:
        '''
        :param index: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__68eda82679aeb758e8687a139bf3ee5d2800f2243a901236e4b3cef260be02a5)
            check_type(argname="argument index", value=index, expected_type=type_hints["index"])
        return typing.cast(IResolvable, jsii.invoke(self, "get", [index]))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3d0ade8582a14194cc75b46f77c5b8df109f2ec8b102a478497f698007c9092c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__698b09e675380c10ead3c5c311f9506414cc3ad235a9cc25f2361e0deab352e8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="wrapsSet")
    def _wraps_set(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "wrapsSet"))

    @_wraps_set.setter
    def _wraps_set(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b20bbabd07aa20d9a6514cf1654223a91e203e83e4f1eda90c27176373d17efe)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "wrapsSet", value) # pyright: ignore[reportArgumentType]


class BooleanListList(
    ComplexList,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.BooleanListList",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
        wraps_set: builtins.bool,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -
        :param wraps_set: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e7318d2496ae2fda0251b23d89a711c859c122533e98b2137d6108fb6914f997)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
            check_type(argname="argument wraps_set", value=wraps_set, expected_type=type_hints["wraps_set"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute, wraps_set])

    @jsii.member(jsii_name="get")
    def get(self, index: jsii.Number) -> IResolvable:
        '''
        :param index: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__48249f4fcfcd1d9ca3b2a2b90f288c88f929d1883af88318c46f22627fe5b97d)
            check_type(argname="argument index", value=index, expected_type=type_hints["index"])
        return typing.cast(IResolvable, jsii.invoke(self, "get", [index]))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__93526987e7d9d0790dca301859bc01255b09e57ff53f0aaac4e1f30230f9cba8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f96d0bb549f495d0eab6b4fbcb03e3e8ae789c426eaa7b9d9ed0d7abcbe72b45)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="wrapsSet")
    def _wraps_set(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "wrapsSet"))

    @_wraps_set.setter
    def _wraps_set(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3969245da87539a1af1854c78d5caaf0e723ab55b85769c48b294cc947eeb14e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "wrapsSet", value) # pyright: ignore[reportArgumentType]


class BooleanListMap(
    ComplexMap,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.BooleanListMap",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        terraform_resource: IInterpolatingParent,
        terraform_attribute: builtins.str,
    ) -> None:
        '''
        :param terraform_resource: -
        :param terraform_attribute: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4ebade8ee10d996689b56a77f18fd4aeb40b11d195d19c34fe6f37b14df75111)
            check_type(argname="argument terraform_resource", value=terraform_resource, expected_type=type_hints["terraform_resource"])
            check_type(argname="argument terraform_attribute", value=terraform_attribute, expected_type=type_hints["terraform_attribute"])
        jsii.create(self.__class__, self, [terraform_resource, terraform_attribute])

    @jsii.member(jsii_name="get")
    def get(self, key: builtins.str) -> IResolvable:
        '''
        :param key: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e5932a388e70b619a5a823c860475b3bf658d0bba559ad077df9caf242d8d95c)
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
        return typing.cast(IResolvable, jsii.invoke(self, "get", [key]))

    @builtins.property
    @jsii.member(jsii_name="terraformAttribute")
    def _terraform_attribute(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "terraformAttribute"))

    @_terraform_attribute.setter
    def _terraform_attribute(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__338bc13eaa1821920b7b5a841d1a3f7892912f8912fbd057ecc4f9d034accbbf)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformAttribute", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="terraformResource")
    def _terraform_resource(self) -> IInterpolatingParent:
        '''
        :stability: experimental
        '''
        return typing.cast(IInterpolatingParent, jsii.get(self, "terraformResource"))

    @_terraform_resource.setter
    def _terraform_resource(self, value: IInterpolatingParent) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b7cf69d6dcd6e992a33d37bb8e8721e52187bc8638d2c285ef4a7caa08cbc8d3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]


class CloudBackend(
    TerraformBackend,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.CloudBackend",
):
    '''(experimental) The Cloud Backend synthesizes a {@link https://developer.hashicorp.com/terraform/cli/cloud/settings#the-cloud-block cloud block}. The cloud block is a nested block within the top-level terraform settings block. It specifies which Terraform Cloud workspaces to use for the current working directory. The cloud block only affects Terraform CLI's behavior. When Terraform Cloud uses a configuration that contains a cloud block - for example, when a workspace is configured to use a VCS provider directly - it ignores the block and behaves according to its own workspace settings.

    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        *,
        organization: builtins.str,
        workspaces: typing.Union[NamedCloudWorkspace, TaggedCloudWorkspaces],
        hostname: typing.Optional[builtins.str] = None,
        token: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param organization: (experimental) The name of the organization containing the workspace(s) the current configuration should use.
        :param workspaces: (experimental) A nested block that specifies which remote Terraform Cloud workspaces to use for the current configuration. The workspaces block must contain exactly one of the following arguments, each denoting a strategy for how workspaces should be mapped:
        :param hostname: (experimental) The hostname of a Terraform Enterprise installation, if using Terraform Enterprise. Default: app.terraform.io
        :param token: (experimental) The token used to authenticate with Terraform Cloud. We recommend omitting the token from the configuration, and instead using terraform login or manually configuring credentials in the CLI config file.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__331792c2de4604487f68c3740cbf3c0843a64da8281b0fa8973ceb13b823544e)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = CloudBackendConfig(
            organization=organization,
            workspaces=workspaces,
            hostname=hostname,
            token=token,
        )

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

    @jsii.member(jsii_name="getRemoteStateDataSource")
    def get_remote_state_data_source(
        self,
        scope: _constructs_77d1e7e8.Construct,
        name: builtins.str,
        _from_stack: builtins.str,
    ) -> TerraformRemoteState:
        '''(experimental) Creates a TerraformRemoteState resource that accesses this backend.

        :param scope: -
        :param name: -
        :param _from_stack: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__29c24ef103ee5a50dc4cf9abe699150f94fde54257af601c4bc918c363500288)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument _from_stack", value=_from_stack, expected_type=type_hints["_from_stack"])
        return typing.cast(TerraformRemoteState, jsii.invoke(self, "getRemoteStateDataSource", [scope, name, _from_stack]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))

    @jsii.member(jsii_name="toHclTerraform")
    def to_hcl_terraform(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toHclTerraform", []))

    @jsii.member(jsii_name="toMetadata")
    def to_metadata(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toMetadata", []))

    @jsii.member(jsii_name="toTerraform")
    def to_terraform(self) -> typing.Any:
        '''(experimental) Adds this resource to the terraform JSON output.

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toTerraform", []))


class ConsulBackend(
    TerraformBackend,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.ConsulBackend",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        *,
        access_token: builtins.str,
        path: builtins.str,
        address: typing.Optional[builtins.str] = None,
        ca_file: typing.Optional[builtins.str] = None,
        cert_file: typing.Optional[builtins.str] = None,
        datacenter: typing.Optional[builtins.str] = None,
        gzip: typing.Optional[builtins.bool] = None,
        http_auth: typing.Optional[builtins.str] = None,
        key_file: typing.Optional[builtins.str] = None,
        lock: typing.Optional[builtins.bool] = None,
        scheme: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param access_token: (experimental) (Required) Access token.
        :param path: (experimental) (Required) Path in the Consul KV store.
        :param address: (experimental) (Optional) DNS name and port of your Consul endpoint specified in the format dnsname:port. Defaults to the local agent HTTP listener.
        :param ca_file: (experimental) (Optional) A path to a PEM-encoded certificate authority used to verify the remote agent's certificate.
        :param cert_file: (experimental) (Optional) A path to a PEM-encoded certificate provided to the remote agent; requires use of key_file.
        :param datacenter: (experimental) (Optional) The datacenter to use. Defaults to that of the agent.
        :param gzip: (experimental) (Optional) true to compress the state data using gzip, or false (the default) to leave it uncompressed.
        :param http_auth: (experimental) (Optional) HTTP Basic Authentication credentials to be used when communicating with Consul, in the format of either user or user:pass.
        :param key_file: (experimental) (Optional) A path to a PEM-encoded private key, required if cert_file is specified.
        :param lock: (experimental) (Optional) false to disable locking. This defaults to true, but will require session permissions with Consul and at least kv write permissions on $path/.lock to perform locking.
        :param scheme: (experimental) (Optional) Specifies what protocol to use when talking to the given address,either http or https. SSL support can also be triggered by setting then environment variable CONSUL_HTTP_SSL to true.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1c0f04aaf6ad07d2cf1cf8126c98306e34215e156109553f4c51e66943d40041)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = ConsulBackendConfig(
            access_token=access_token,
            path=path,
            address=address,
            ca_file=ca_file,
            cert_file=cert_file,
            datacenter=datacenter,
            gzip=gzip,
            http_auth=http_auth,
            key_file=key_file,
            lock=lock,
            scheme=scheme,
        )

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

    @jsii.member(jsii_name="getRemoteStateDataSource")
    def get_remote_state_data_source(
        self,
        scope: _constructs_77d1e7e8.Construct,
        name: builtins.str,
        _from_stack: builtins.str,
    ) -> TerraformRemoteState:
        '''(experimental) Creates a TerraformRemoteState resource that accesses this backend.

        :param scope: -
        :param name: -
        :param _from_stack: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d1d604635997895c64949524ea9cf4989df66b39f44f4e2967ce0c074b18a550)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument _from_stack", value=_from_stack, expected_type=type_hints["_from_stack"])
        return typing.cast(TerraformRemoteState, jsii.invoke(self, "getRemoteStateDataSource", [scope, name, _from_stack]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))


class CosBackend(
    TerraformBackend,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.CosBackend",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        *,
        bucket: builtins.str,
        accelerate: typing.Optional[builtins.bool] = None,
        acl: typing.Optional[builtins.str] = None,
        assume_role: typing.Optional[typing.Union[CosBackendAssumeRole, typing.Dict[builtins.str, typing.Any]]] = None,
        domain: typing.Optional[builtins.str] = None,
        encrypt: typing.Optional[builtins.bool] = None,
        endpoint: typing.Optional[builtins.str] = None,
        key: typing.Optional[builtins.str] = None,
        prefix: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        secret_id: typing.Optional[builtins.str] = None,
        secret_key: typing.Optional[builtins.str] = None,
        security_token: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param bucket: (experimental) (Required) The name of the COS bucket. You shall manually create it first.
        :param accelerate: (experimental) (Optional) Whether to enable global Acceleration. Defaults to false.
        :param acl: (experimental) (Optional) Object ACL to be applied to the state file, allows private and public-read. Defaults to private.
        :param assume_role: (experimental) (Optional) The assume_role block. If provided, terraform will attempt to assume this role using the supplied credentials.
        :param domain: (experimental) (Optional) The root domain of the API request. Defaults to tencentcloudapi.com. It supports the environment variable TENCENTCLOUD_DOMAIN.
        :param encrypt: (experimental) (Optional) Whether to enable server side encryption of the state file. If it is true, COS will use 'AES256' encryption algorithm to encrypt state file.
        :param endpoint: (experimental) (Optional) The Custom Endpoint for the COS backend. It supports the environment variable TENCENTCLOUD_ENDPOINT.
        :param key: (experimental) (Optional) The path for saving the state file in bucket. Defaults to terraform.tfstate.
        :param prefix: (experimental) (Optional) The directory for saving the state file in bucket. Default to "env:".
        :param region: (experimental) (Optional) The region of the COS bucket. It supports environment variables TENCENTCLOUD_REGION.
        :param secret_id: (experimental) (Optional) Secret id of Tencent Cloud. It supports environment variables TENCENTCLOUD_SECRET_ID.
        :param secret_key: (experimental) (Optional) Secret key of Tencent Cloud. It supports environment variables TENCENTCLOUD_SECRET_KEY.
        :param security_token: (experimental) (Optional) TencentCloud Security Token of temporary access credentials. It supports environment variables TENCENTCLOUD_SECURITY_TOKEN.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2394cbc768287376b2da96c9afa8aec990b720def99495d34ab4f48efafa2553)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = CosBackendConfig(
            bucket=bucket,
            accelerate=accelerate,
            acl=acl,
            assume_role=assume_role,
            domain=domain,
            encrypt=encrypt,
            endpoint=endpoint,
            key=key,
            prefix=prefix,
            region=region,
            secret_id=secret_id,
            secret_key=secret_key,
            security_token=security_token,
        )

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

    @jsii.member(jsii_name="getRemoteStateDataSource")
    def get_remote_state_data_source(
        self,
        scope: _constructs_77d1e7e8.Construct,
        name: builtins.str,
        _from_stack: builtins.str,
    ) -> TerraformRemoteState:
        '''(experimental) Creates a TerraformRemoteState resource that accesses this backend.

        :param scope: -
        :param name: -
        :param _from_stack: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__451d285c30124aec226ca021b899bb920d0d4c5e352d21a6ccc0f12c3b3036b0)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument _from_stack", value=_from_stack, expected_type=type_hints["_from_stack"])
        return typing.cast(TerraformRemoteState, jsii.invoke(self, "getRemoteStateDataSource", [scope, name, _from_stack]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))


class DynamicListTerraformIterator(
    MapTerraformIterator,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.DynamicListTerraformIterator",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        list: typing.Union[typing.Sequence[builtins.str], IResolvable, typing.Sequence[jsii.Number], typing.Sequence[typing.Union[builtins.bool, IResolvable]]],
        map_key_attribute_name: builtins.str,
    ) -> None:
        '''
        :param list: -
        :param map_key_attribute_name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__719efb4389e7414eff4c0b125ef326f8d84f246be0facc93a1ec7b3c749638ca)
            check_type(argname="argument list", value=list, expected_type=type_hints["list"])
            check_type(argname="argument map_key_attribute_name", value=map_key_attribute_name, expected_type=type_hints["map_key_attribute_name"])
        jsii.create(self.__class__, self, [list, map_key_attribute_name])


class GcsBackend(
    TerraformBackend,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.GcsBackend",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        *,
        bucket: builtins.str,
        access_token: typing.Optional[builtins.str] = None,
        credentials: typing.Optional[builtins.str] = None,
        encryption_key: typing.Optional[builtins.str] = None,
        impersonate_service_account: typing.Optional[builtins.str] = None,
        impersonate_service_account_delegates: typing.Optional[typing.Sequence[builtins.str]] = None,
        kms_encryption_key: typing.Optional[builtins.str] = None,
        prefix: typing.Optional[builtins.str] = None,
        storeage_custom_endpoint: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param bucket: (experimental) (Required) The name of the GCS bucket. This name must be globally unique.
        :param access_token: (experimental) (Optional) A temporary [OAuth 2.0 access token] obtained from the Google Authorization server, i.e. the Authorization: Bearer token used to authenticate HTTP requests to GCP APIs. This is an alternative to credentials. If both are specified, access_token will be used over the credentials field.
        :param credentials: (experimental) (Optional) Local path to Google Cloud Platform account credentials in JSON format. If unset, Google Application Default Credentials are used. The provided credentials must have Storage Object Admin role on the bucket. Warning: if using the Google Cloud Platform provider as well, it will also pick up the GOOGLE_CREDENTIALS environment variable.
        :param encryption_key: (experimental) (Optional) A 32 byte base64 encoded 'customer supplied encryption key' used to encrypt all state.
        :param impersonate_service_account: (experimental) (Optional) The service account to impersonate for accessing the State Bucket. You must have roles/iam.serviceAccountTokenCreator role on that account for the impersonation to succeed. If you are using a delegation chain, you can specify that using the impersonate_service_account_delegates field. Alternatively, this can be specified using the GOOGLE_IMPERSONATE_SERVICE_ACCOUNT environment variable.
        :param impersonate_service_account_delegates: (experimental) (Optional) The delegation chain for an impersonating a service account.
        :param kms_encryption_key: (experimental) (Optional) A Cloud KMS key ('customer-managed encryption key') used when reading and writing state files in the bucket. Format should be projects/{{project}}/locations/{{location}}/keyRings/{{keyRing}}/cryptoKeys/{{name}}. For more information, including IAM requirements, see {@link https://cloud.google.com/storage/docs/encryption/customer-managed-keys Customer-managed Encryption Keys}.
        :param prefix: (experimental) (Optional) GCS prefix inside the bucket. Named states for workspaces are stored in an object called /.tfstate.
        :param storeage_custom_endpoint: (experimental) (Optional) A URL containing three parts: the protocol, the DNS name pointing to a Private Service Connect endpoint, and the path for the Cloud Storage API (/storage/v1/b). {@link https://developer.hashicorp.com/terraform/language/settings/backends/gcs#storage_custom_endpoint See here for more details}

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__baafae26b6a889becc40942b4e642fadedea6528655ef52c76baaa236bed7dd5)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = GcsBackendConfig(
            bucket=bucket,
            access_token=access_token,
            credentials=credentials,
            encryption_key=encryption_key,
            impersonate_service_account=impersonate_service_account,
            impersonate_service_account_delegates=impersonate_service_account_delegates,
            kms_encryption_key=kms_encryption_key,
            prefix=prefix,
            storeage_custom_endpoint=storeage_custom_endpoint,
        )

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

    @jsii.member(jsii_name="getRemoteStateDataSource")
    def get_remote_state_data_source(
        self,
        scope: _constructs_77d1e7e8.Construct,
        name: builtins.str,
        _from_stack: builtins.str,
    ) -> TerraformRemoteState:
        '''(experimental) Creates a TerraformRemoteState resource that accesses this backend.

        :param scope: -
        :param name: -
        :param _from_stack: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d4c92042ee61291ae24b02195f9d57c4be65b0d43025cf71bb72e9109507d868)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument _from_stack", value=_from_stack, expected_type=type_hints["_from_stack"])
        return typing.cast(TerraformRemoteState, jsii.invoke(self, "getRemoteStateDataSource", [scope, name, _from_stack]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))


class HttpBackend(
    TerraformBackend,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.HttpBackend",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        *,
        address: builtins.str,
        client_ca_certificate_pem: typing.Optional[builtins.str] = None,
        client_certificate_pem: typing.Optional[builtins.str] = None,
        client_private_key_pem: typing.Optional[builtins.str] = None,
        lock_address: typing.Optional[builtins.str] = None,
        lock_method: typing.Optional[builtins.str] = None,
        password: typing.Optional[builtins.str] = None,
        retry_max: typing.Optional[jsii.Number] = None,
        retry_wait_max: typing.Optional[jsii.Number] = None,
        retry_wait_min: typing.Optional[jsii.Number] = None,
        skip_cert_verification: typing.Optional[builtins.bool] = None,
        unlock_address: typing.Optional[builtins.str] = None,
        unlock_method: typing.Optional[builtins.str] = None,
        update_method: typing.Optional[builtins.str] = None,
        username: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param address: (experimental) (Required) The address of the REST endpoint.
        :param client_ca_certificate_pem: (experimental) (Optional) A PEM-encoded CA certificate chain used by the client to verify server certificates during TLS authentication.
        :param client_certificate_pem: (experimental) (Optional) A PEM-encoded certificate used by the server to verify the client during mutual TLS (mTLS) authentication.
        :param client_private_key_pem: (experimental) (Optional) A PEM-encoded private key, required if client_certificate_pem is specified.
        :param lock_address: (experimental) (Optional) The address of the lock REST endpoint. Defaults to disabled.
        :param lock_method: (experimental) (Optional) The HTTP method to use when locking. Defaults to LOCK.
        :param password: (experimental) (Optional) The password for HTTP basic authentication.
        :param retry_max: (experimental) (Optional) The number of HTTP request retries. Defaults to 2.
        :param retry_wait_max: (experimental) (Optional) The maximum time in seconds to wait between HTTP request attempts. Defaults to 30.
        :param retry_wait_min: (experimental) (Optional) The minimum time in seconds to wait between HTTP request attempts. Defaults to 1.
        :param skip_cert_verification: (experimental) (Optional) Whether to skip TLS verification. Defaults to false.
        :param unlock_address: (experimental) (Optional) The address of the unlock REST endpoint. Defaults to disabled.
        :param unlock_method: (experimental) (Optional) The HTTP method to use when unlocking. Defaults to UNLOCK.
        :param update_method: (experimental) (Optional) HTTP method to use when updating state. Defaults to POST.
        :param username: (experimental) (Optional) The username for HTTP basic authentication.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cb23c48335c86e5c3266d50d65a674729ade9aae8e42685c16f39ecc1c426bd3)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = HttpBackendConfig(
            address=address,
            client_ca_certificate_pem=client_ca_certificate_pem,
            client_certificate_pem=client_certificate_pem,
            client_private_key_pem=client_private_key_pem,
            lock_address=lock_address,
            lock_method=lock_method,
            password=password,
            retry_max=retry_max,
            retry_wait_max=retry_wait_max,
            retry_wait_min=retry_wait_min,
            skip_cert_verification=skip_cert_verification,
            unlock_address=unlock_address,
            unlock_method=unlock_method,
            update_method=update_method,
            username=username,
        )

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

    @jsii.member(jsii_name="getRemoteStateDataSource")
    def get_remote_state_data_source(
        self,
        scope: _constructs_77d1e7e8.Construct,
        name: builtins.str,
        _from_stack: builtins.str,
    ) -> TerraformRemoteState:
        '''(experimental) Creates a TerraformRemoteState resource that accesses this backend.

        :param scope: -
        :param name: -
        :param _from_stack: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3baeb366dadee6b13ee5c5aabc082edf54fc5d4869e870e45f1b1df87f6fe616)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument _from_stack", value=_from_stack, expected_type=type_hints["_from_stack"])
        return typing.cast(TerraformRemoteState, jsii.invoke(self, "getRemoteStateDataSource", [scope, name, _from_stack]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))


class LocalBackend(
    TerraformBackend,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.LocalBackend",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        *,
        path: typing.Optional[builtins.str] = None,
        workspace_dir: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param path: (experimental) Path where the state file is stored. Default: - defaults to terraform.${stackId}.tfstate
        :param workspace_dir: (experimental) (Optional) The path to non-default workspaces.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__860cd4f6fc700209940bb21cd07a6577d543d0e77de9598c110fea15f6c9f7f2)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = LocalBackendConfig(path=path, workspace_dir=workspace_dir)

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

    @jsii.member(jsii_name="getRemoteStateDataSource")
    def get_remote_state_data_source(
        self,
        scope: _constructs_77d1e7e8.Construct,
        name: builtins.str,
        from_stack: builtins.str,
    ) -> TerraformRemoteState:
        '''(experimental) Creates a TerraformRemoteState resource that accesses this backend.

        :param scope: -
        :param name: -
        :param from_stack: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fe6060cfa841d804b355096acd4084886a30d4df596da42f180e12d5978169bb)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument from_stack", value=from_stack, expected_type=type_hints["from_stack"])
        return typing.cast(TerraformRemoteState, jsii.invoke(self, "getRemoteStateDataSource", [scope, name, from_stack]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))


class OssBackend(
    TerraformBackend,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.OssBackend",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        *,
        bucket: builtins.str,
        access_key: typing.Optional[builtins.str] = None,
        acl: typing.Optional[builtins.str] = None,
        assume_role: typing.Optional[typing.Union[OssAssumeRole, typing.Dict[builtins.str, typing.Any]]] = None,
        assume_role_policy: typing.Optional[builtins.str] = None,
        assume_role_role_arn: typing.Optional[builtins.str] = None,
        assume_role_session_expiration: typing.Optional[jsii.Number] = None,
        assume_role_session_name: typing.Optional[builtins.str] = None,
        ecs_role_name: typing.Optional[builtins.str] = None,
        encrypt: typing.Optional[builtins.bool] = None,
        endpoint: typing.Optional[builtins.str] = None,
        key: typing.Optional[builtins.str] = None,
        prefix: typing.Optional[builtins.str] = None,
        profile: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        secret_key: typing.Optional[builtins.str] = None,
        security_token: typing.Optional[builtins.str] = None,
        shared_credentials_file: typing.Optional[builtins.str] = None,
        sts_endpoint: typing.Optional[builtins.str] = None,
        tablestore_endpoint: typing.Optional[builtins.str] = None,
        tablestore_table: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param bucket: (experimental) (Required) The name of the OSS bucket.
        :param access_key: (experimental) (Optional) Alibaba Cloud access key. It supports environment variables ALICLOUD_ACCESS_KEY and ALICLOUD_ACCESS_KEY_ID.
        :param acl: (experimental) (Optional) Object ACL to be applied to the state file.
        :param assume_role: 
        :param assume_role_policy: (experimental) (Optional, Available in 1.1.0+) A more restrictive policy to apply to the temporary credentials. This gives you a way to further restrict the permissions for the resulting temporary security credentials. You cannot use this policy to grant permissions that exceed those of the role that is being assumed.
        :param assume_role_role_arn: (experimental) (Optional, Available in 1.1.0+) The ARN of the role to assume. If ARN is set to an empty string, it does not perform role switching. It supports the environment variable ALICLOUD_ASSUME_ROLE_ARN. Terraform executes configuration on account with provided credentials.
        :param assume_role_session_expiration: (experimental) (Optional, Available in 1.1.0+) The time after which the established session for assuming role expires. Valid value range: [900-3600] seconds. Default to 3600 (in this case Alibaba Cloud uses its own default value). It supports environment variable ALICLOUD_ASSUME_ROLE_SESSION_EXPIRATION.
        :param assume_role_session_name: (experimental) (Optional, Available in 1.1.0+) The session name to use when assuming the role. If omitted, 'terraform' is passed to the AssumeRole call as session name. It supports environment variable ALICLOUD_ASSUME_ROLE_SESSION_NAME.
        :param ecs_role_name: (experimental) (Optional, Available in 0.12.14+) The RAM Role Name attached on a ECS instance for API operations. You can retrieve this from the 'Access Control' section of the Alibaba Cloud console.
        :param encrypt: (experimental) (Optional) Whether to enable server side encryption of the state file. If it is true, OSS will use 'AES256' encryption algorithm to encrypt state file.
        :param endpoint: (experimental) (Optional) A custom endpoint for the OSS API. It supports environment variables ALICLOUD_OSS_ENDPOINT and OSS_ENDPOINT.
        :param key: (experimental) (Optional) The name of the state file. Defaults to terraform.tfstate.
        :param prefix: (experimental) (Optional) The path directory of the state file will be stored. Default to "env:".
        :param profile: (experimental) (Optional, Available in 0.12.8+) This is the Alibaba Cloud profile name as set in the shared credentials file. It can also be sourced from the ALICLOUD_PROFILE environment variable.
        :param region: (experimental) (Optional) The region of the OSS bucket. It supports environment variables ALICLOUD_REGION and ALICLOUD_DEFAULT_REGION.
        :param secret_key: (experimental) (Optional) Alibaba Cloud secret access key. It supports environment variables ALICLOUD_SECRET_KEY and ALICLOUD_ACCESS_KEY_SECRET.
        :param security_token: (experimental) (Optional) STS access token. It supports environment variable ALICLOUD_SECURITY_TOKEN.
        :param shared_credentials_file: (experimental) (Optional, Available in 0.12.8+) This is the path to the shared credentials file. It can also be sourced from the ALICLOUD_SHARED_CREDENTIALS_FILE environment variable. If this is not set and a profile is specified, ~/.aliyun/config.json will be used.
        :param sts_endpoint: (experimental) (Optional, Available in 1.0.11+) Custom endpoint for the AliCloud Security Token Service (STS) API. It supports environment variable ALICLOUD_STS_ENDPOINT.
        :param tablestore_endpoint: (experimental) (Optional) A custom endpoint for the TableStore API.
        :param tablestore_table: (experimental) (Optional) A TableStore table for state locking and consistency. The table must have a primary key named LockID of type String.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ae449e73ed2b213fd2f1632d9f3c6e00fbacd80d9a8f5a033c9a9217b3113929)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = OssBackendConfig(
            bucket=bucket,
            access_key=access_key,
            acl=acl,
            assume_role=assume_role,
            assume_role_policy=assume_role_policy,
            assume_role_role_arn=assume_role_role_arn,
            assume_role_session_expiration=assume_role_session_expiration,
            assume_role_session_name=assume_role_session_name,
            ecs_role_name=ecs_role_name,
            encrypt=encrypt,
            endpoint=endpoint,
            key=key,
            prefix=prefix,
            profile=profile,
            region=region,
            secret_key=secret_key,
            security_token=security_token,
            shared_credentials_file=shared_credentials_file,
            sts_endpoint=sts_endpoint,
            tablestore_endpoint=tablestore_endpoint,
            tablestore_table=tablestore_table,
        )

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

    @jsii.member(jsii_name="getRemoteStateDataSource")
    def get_remote_state_data_source(
        self,
        scope: _constructs_77d1e7e8.Construct,
        name: builtins.str,
        _from_stack: builtins.str,
    ) -> TerraformRemoteState:
        '''(experimental) Creates a TerraformRemoteState resource that accesses this backend.

        :param scope: -
        :param name: -
        :param _from_stack: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__73d96547aed7957cff901daf09712606a82d01e15ff92391d2ff5a47973ea87f)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument _from_stack", value=_from_stack, expected_type=type_hints["_from_stack"])
        return typing.cast(TerraformRemoteState, jsii.invoke(self, "getRemoteStateDataSource", [scope, name, _from_stack]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))


class PgBackend(TerraformBackend, metaclass=jsii.JSIIMeta, jsii_type="cdktn.PgBackend"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        *,
        conn_str: builtins.str,
        schema_name: typing.Optional[builtins.str] = None,
        skip_index_creation: typing.Optional[builtins.bool] = None,
        skip_schema_creation: typing.Optional[builtins.bool] = None,
        skip_table_creation: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param conn_str: (experimental) Postgres connection string; a postgres:// URL. The PG_CONN_STR and standard libpq environment variables can also be used to indicate how to connect to the PostgreSQL database.
        :param schema_name: (experimental) Name of the automatically-managed Postgres schema, default to terraform_remote_state. Can also be set using the PG_SCHEMA_NAME environment variable.
        :param skip_index_creation: (experimental) If set to true, the Postgres index must already exist. Can also be set using the PG_SKIP_INDEX_CREATION environment variable. Terraform won't try to create the index, this is useful when it has already been created by a database administrator.
        :param skip_schema_creation: (experimental) If set to true, the Postgres schema must already exist. Can also be set using the PG_SKIP_SCHEMA_CREATION environment variable. Terraform won't try to create the schema, this is useful when it has already been created by a database administrator.
        :param skip_table_creation: (experimental) If set to true, the Postgres table must already exist. Can also be set using the PG_SKIP_TABLE_CREATION environment variable. Terraform won't try to create the table, this is useful when it has already been created by a database administrator.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__97fb1722ae8e5fdce1b872e63a314eac25a11aced7005ba54383a6bc1735c682)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = PgBackendConfig(
            conn_str=conn_str,
            schema_name=schema_name,
            skip_index_creation=skip_index_creation,
            skip_schema_creation=skip_schema_creation,
            skip_table_creation=skip_table_creation,
        )

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

    @jsii.member(jsii_name="getRemoteStateDataSource")
    def get_remote_state_data_source(
        self,
        scope: _constructs_77d1e7e8.Construct,
        name: builtins.str,
        _from_stack: builtins.str,
    ) -> TerraformRemoteState:
        '''(experimental) Creates a TerraformRemoteState resource that accesses this backend.

        :param scope: -
        :param name: -
        :param _from_stack: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1dfb6f6ae50330a275e0d273ef1f77b9dd57a25c662b3bfc0a4f3daf8f6eee8b)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument _from_stack", value=_from_stack, expected_type=type_hints["_from_stack"])
        return typing.cast(TerraformRemoteState, jsii.invoke(self, "getRemoteStateDataSource", [scope, name, _from_stack]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))


class RemoteBackend(
    TerraformBackend,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.RemoteBackend",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        *,
        organization: builtins.str,
        workspaces: IRemoteWorkspace,
        hostname: typing.Optional[builtins.str] = None,
        token: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param organization: 
        :param workspaces: 
        :param hostname: 
        :param token: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fb0d897bb4f2791521d8313101eb7c0d233f466883cf7a4168f3404a42038d44)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = RemoteBackendConfig(
            organization=organization,
            workspaces=workspaces,
            hostname=hostname,
            token=token,
        )

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

    @jsii.member(jsii_name="getRemoteStateDataSource")
    def get_remote_state_data_source(
        self,
        scope: _constructs_77d1e7e8.Construct,
        name: builtins.str,
        _from_stack: builtins.str,
    ) -> TerraformRemoteState:
        '''(experimental) Creates a TerraformRemoteState resource that accesses this backend.

        :param scope: -
        :param name: -
        :param _from_stack: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__916a20c8f185c3b695f06f50af5791cd56649a4990bb89b8185197743ba910c9)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument _from_stack", value=_from_stack, expected_type=type_hints["_from_stack"])
        return typing.cast(TerraformRemoteState, jsii.invoke(self, "getRemoteStateDataSource", [scope, name, _from_stack]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))

    @jsii.member(jsii_name="toMetadata")
    def to_metadata(self) -> typing.Any:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.invoke(self, "toMetadata", []))


class S3Backend(TerraformBackend, metaclass=jsii.JSIIMeta, jsii_type="cdktn.S3Backend"):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        *,
        bucket: builtins.str,
        key: builtins.str,
        access_key: typing.Optional[builtins.str] = None,
        acl: typing.Optional[builtins.str] = None,
        allowed_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        assume_role: typing.Optional[typing.Union[S3BackendAssumeRoleConfig, typing.Dict[builtins.str, typing.Any]]] = None,
        assume_role_policy: typing.Optional[builtins.str] = None,
        assume_role_policy_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
        assume_role_tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        assume_role_transitive_tag_keys: typing.Optional[typing.Sequence[builtins.str]] = None,
        assume_role_with_web_identity: typing.Optional[typing.Union[S3BackendAssumeRoleWithWebIdentityConfig, typing.Dict[builtins.str, typing.Any]]] = None,
        custom_ca_bundle: typing.Optional[builtins.str] = None,
        dynamodb_endpoint: typing.Optional[builtins.str] = None,
        dynamodb_table: typing.Optional[builtins.str] = None,
        ec2_metadata_service_endpoint: typing.Optional[builtins.str] = None,
        ec2_metadata_service_endpoint_mode: typing.Optional[builtins.str] = None,
        encrypt: typing.Optional[builtins.bool] = None,
        endpoint: typing.Optional[builtins.str] = None,
        endpoints: typing.Optional[typing.Union[S3BackendEndpointConfig, typing.Dict[builtins.str, typing.Any]]] = None,
        external_id: typing.Optional[builtins.str] = None,
        forbidden_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        force_path_style: typing.Optional[builtins.bool] = None,
        http_proxy: typing.Optional[builtins.str] = None,
        https_proxy: typing.Optional[builtins.str] = None,
        iam_endpoint: typing.Optional[builtins.str] = None,
        insecure: typing.Optional[builtins.bool] = None,
        kms_key_id: typing.Optional[builtins.str] = None,
        max_retries: typing.Optional[jsii.Number] = None,
        no_proxy: typing.Optional[builtins.str] = None,
        profile: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        retry_mode: typing.Optional[builtins.str] = None,
        role_arn: typing.Optional[builtins.str] = None,
        secret_key: typing.Optional[builtins.str] = None,
        session_name: typing.Optional[builtins.str] = None,
        shared_config_files: typing.Optional[typing.Sequence[builtins.str]] = None,
        shared_credentials_file: typing.Optional[builtins.str] = None,
        shared_credentials_files: typing.Optional[typing.Sequence[builtins.str]] = None,
        skip_credentials_validation: typing.Optional[builtins.bool] = None,
        skip_metadata_api_check: typing.Optional[builtins.bool] = None,
        skip_region_validation: typing.Optional[builtins.bool] = None,
        skip_requesting_account_id: typing.Optional[builtins.bool] = None,
        skip_s3_checksum: typing.Optional[builtins.bool] = None,
        sse_customer_key: typing.Optional[builtins.str] = None,
        sts_endpoint: typing.Optional[builtins.str] = None,
        sts_region: typing.Optional[builtins.str] = None,
        token: typing.Optional[builtins.str] = None,
        use_legacy_workflow: typing.Optional[builtins.bool] = None,
        use_path_style: typing.Optional[builtins.bool] = None,
        workspace_key_prefix: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param bucket: (experimental) Name of the S3 Bucket.
        :param key: (experimental) Path to the state file inside the S3 Bucket. When using a non-default workspace, the state path will be /workspace_key_prefix/workspace_name/key
        :param access_key: (experimental) (Optional) AWS access key. If configured, must also configure secret_key. This can also be sourced from the AWS_ACCESS_KEY_ID environment variable, AWS shared credentials file (e.g. ~/.aws/credentials), or AWS shared configuration file (e.g. ~/.aws/config).
        :param acl: (experimental) (Optional) Canned ACL to be applied to the state file.
        :param allowed_account_ids: (experimental) (Optional) List of allowed AWS account IDs to prevent potential destruction of a live environment. Conflicts with forbidden_account_ids.
        :param assume_role: (experimental) Assuming an IAM Role can be configured in two ways. The preferred way is to use the argument assume_role, the other, which is deprecated, is with arguments at the top level.
        :param assume_role_policy: (deprecated) (Optional) IAM Policy JSON describing further restricting permissions for the IAM Role being assumed.
        :param assume_role_policy_arns: (deprecated) (Optional) Set of Amazon Resource Names (ARNs) of IAM Policies describing further restricting permissions for the IAM Role being assumed.
        :param assume_role_tags: (deprecated) (Optional) Map of assume role session tags.
        :param assume_role_transitive_tag_keys: (deprecated) (Optional) Set of assume role session tag keys to pass to any subsequent sessions.
        :param assume_role_with_web_identity: (experimental) Assume Role With Web Identity Configuration.
        :param custom_ca_bundle: (experimental) (Optional) File containing custom root and intermediate certificates. Can also be set using the AWS_CA_BUNDLE environment variable. Setting ca_bundle in the shared config file is not supported.
        :param dynamodb_endpoint: (deprecated) (Optional) Custom endpoint for the AWS DynamoDB API. This can also be sourced from the AWS_DYNAMODB_ENDPOINT environment variable.
        :param dynamodb_table: (experimental) (Optional) Name of DynamoDB Table to use for state locking and consistency. The table must have a partition key named LockID with type of String. If not configured, state locking will be disabled.
        :param ec2_metadata_service_endpoint: (experimental) Optional) Custom endpoint URL for the EC2 Instance Metadata Service (IMDS) API. Can also be set with the AWS_EC2_METADATA_SERVICE_ENDPOINT environment variable.
        :param ec2_metadata_service_endpoint_mode: (experimental) (Optional) Mode to use in communicating with the metadata service. Valid values are IPv4 and IPv6. Can also be set with the AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE environment variable.
        :param encrypt: (experimental) (Optional) Enable server side encryption of the state file.
        :param endpoint: (deprecated) (Optional) Custom endpoint for the AWS S3 API. This can also be sourced from the AWS_S3_ENDPOINT environment variable.
        :param endpoints: (experimental) (Optional) The endpoint configuration block.
        :param external_id: (deprecated) (Optional) External identifier to use when assuming the role.
        :param forbidden_account_ids: (experimental) (Optional) List of forbidden AWS account IDs to prevent potential destruction of a live environment. Conflicts with allowed_account_ids.
        :param force_path_style: (deprecated) (Optional) Enable path-style S3 URLs (https:/// instead of https://.).
        :param http_proxy: (experimental) (Optional) URL of a proxy to use for HTTP requests when accessing the AWS API. Can also be set using the HTTP_PROXY or http_proxy environment variables.
        :param https_proxy: (experimental) (Optional) URL of a proxy to use for HTTPS requests when accessing the AWS API. Can also be set using the HTTPS_PROXY or https_proxy environment variables.
        :param iam_endpoint: (deprecated) (Optional) Custom endpoint for the AWS Identity and Access Management (IAM) API. This can also be sourced from the AWS_IAM_ENDPOINT environment variable.
        :param insecure: (experimental) Optional) Whether to explicitly allow the backend to perform "insecure" SSL requests. If omitted, the default value is false.
        :param kms_key_id: (experimental) (Optional) Amazon Resource Name (ARN) of a Key Management Service (KMS) Key to use for encrypting the state. Note that if this value is specified, Terraform will need kms:Encrypt, kms:Decrypt and kms:GenerateDataKey permissions on this KMS key.
        :param max_retries: (experimental) (Optional) The maximum number of times an AWS API request is retried on retryable failure. Defaults to 5.
        :param no_proxy: (experimental) (Optional) Comma-separated list of hosts that should not use HTTP or HTTPS proxies. Each value can be one of: - A domain name - An IP address - A CIDR address - An asterisk (*), to indicate that no proxying should be performed Domain name and IP address values can also include a port number. Can also be set using the NO_PROXY or no_proxy environment variables.
        :param profile: (experimental) (Optional) Name of AWS profile in AWS shared credentials file (e.g. ~/.aws/credentials) or AWS shared configuration file (e.g. ~/.aws/config) to use for credentials and/or configuration. This can also be sourced from the AWS_PROFILE environment variable.
        :param region: (experimental) AWS Region of the S3 Bucket and DynamoDB Table (if used). This can also be sourced from the AWS_DEFAULT_REGION and AWS_REGION environment variables.
        :param retry_mode: (experimental) (Optional) Specifies how retries are attempted. Valid values are standard and adaptive. Can also be configured using the AWS_RETRY_MODE environment variable or the shared config file parameter retry_mode.
        :param role_arn: (deprecated) (Optional) Amazon Resource Name (ARN) of the IAM Role to assume.
        :param secret_key: (experimental) (Optional) AWS secret access key. If configured, must also configure access_key. This can also be sourced from the AWS_SECRET_ACCESS_KEY environment variable, AWS shared credentials file (e.g. ~/.aws/credentials), or AWS shared configuration file (e.g. ~/.aws/config)
        :param session_name: (deprecated) (Optional) Session name to use when assuming the role.
        :param shared_config_files: (experimental) (Optional) List of paths to AWS shared configuration files. Defaults to ~/.aws/config.
        :param shared_credentials_file: (experimental) (Optional) Path to the AWS shared credentials file. Defaults to ~/.aws/credentials.
        :param shared_credentials_files: (experimental) (Optional) List of paths to AWS shared credentials files. Defaults to ~/.aws/credentials.
        :param skip_credentials_validation: (experimental) (Optional) Skip credentials validation via the STS API.
        :param skip_metadata_api_check: (experimental) (Optional) Skip usage of EC2 Metadata API.
        :param skip_region_validation: (experimental) (Optional) Skip validation of provided region name.
        :param skip_requesting_account_id: (experimental) (Optional) Whether to skip requesting the account ID. Useful for AWS API implementations that do not have the IAM, STS API, or metadata API.
        :param skip_s3_checksum: (experimental) (Optional) Do not include checksum when uploading S3 Objects. Useful for some S3-Compatible APIs.
        :param sse_customer_key: (experimental) (Optional) The key to use for encrypting state with Server-Side Encryption with Customer-Provided Keys (SSE-C). This is the base64-encoded value of the key, which must decode to 256 bits. This can also be sourced from the AWS_SSE_CUSTOMER_KEY environment variable, which is recommended due to the sensitivity of the value. Setting it inside a terraform file will cause it to be persisted to disk in terraform.tfstate.
        :param sts_endpoint: (deprecated) (Optional) Custom endpoint for the AWS Security Token Service (STS) API. This can also be sourced from the AWS_STS_ENDPOINT environment variable.
        :param sts_region: (experimental) (Optional) AWS region for STS. If unset, AWS will use the same region for STS as other non-STS operations.
        :param token: (experimental) (Optional) Multi-Factor Authentication (MFA) token. This can also be sourced from the AWS_SESSION_TOKEN environment variable.
        :param use_legacy_workflow: (experimental) (Optional) Use the legacy authentication workflow, preferring environment variables over backend configuration. Defaults to true. This behavior does not align with the authentication flow of the AWS CLI or SDK's, and will be removed in the future.
        :param use_path_style: (experimental) (Optional) Enable path-style S3 URLs (https:/// instead of https://.).
        :param workspace_key_prefix: (experimental) (Optional) Prefix applied to the state path inside the bucket. This is only relevant when using a non-default workspace. Defaults to env:

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e38d6db5faac22bddc00a3c059dc3fc9e166d2cccc34df67a51fe136a3313a46)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = S3BackendConfig(
            bucket=bucket,
            key=key,
            access_key=access_key,
            acl=acl,
            allowed_account_ids=allowed_account_ids,
            assume_role=assume_role,
            assume_role_policy=assume_role_policy,
            assume_role_policy_arns=assume_role_policy_arns,
            assume_role_tags=assume_role_tags,
            assume_role_transitive_tag_keys=assume_role_transitive_tag_keys,
            assume_role_with_web_identity=assume_role_with_web_identity,
            custom_ca_bundle=custom_ca_bundle,
            dynamodb_endpoint=dynamodb_endpoint,
            dynamodb_table=dynamodb_table,
            ec2_metadata_service_endpoint=ec2_metadata_service_endpoint,
            ec2_metadata_service_endpoint_mode=ec2_metadata_service_endpoint_mode,
            encrypt=encrypt,
            endpoint=endpoint,
            endpoints=endpoints,
            external_id=external_id,
            forbidden_account_ids=forbidden_account_ids,
            force_path_style=force_path_style,
            http_proxy=http_proxy,
            https_proxy=https_proxy,
            iam_endpoint=iam_endpoint,
            insecure=insecure,
            kms_key_id=kms_key_id,
            max_retries=max_retries,
            no_proxy=no_proxy,
            profile=profile,
            region=region,
            retry_mode=retry_mode,
            role_arn=role_arn,
            secret_key=secret_key,
            session_name=session_name,
            shared_config_files=shared_config_files,
            shared_credentials_file=shared_credentials_file,
            shared_credentials_files=shared_credentials_files,
            skip_credentials_validation=skip_credentials_validation,
            skip_metadata_api_check=skip_metadata_api_check,
            skip_region_validation=skip_region_validation,
            skip_requesting_account_id=skip_requesting_account_id,
            skip_s3_checksum=skip_s3_checksum,
            sse_customer_key=sse_customer_key,
            sts_endpoint=sts_endpoint,
            sts_region=sts_region,
            token=token,
            use_legacy_workflow=use_legacy_workflow,
            use_path_style=use_path_style,
            workspace_key_prefix=workspace_key_prefix,
        )

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

    @jsii.member(jsii_name="getRemoteStateDataSource")
    def get_remote_state_data_source(
        self,
        scope: _constructs_77d1e7e8.Construct,
        name: builtins.str,
        _from_stack: builtins.str,
    ) -> TerraformRemoteState:
        '''(experimental) Creates a TerraformRemoteState resource that accesses this backend.

        :param scope: -
        :param name: -
        :param _from_stack: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8b33c44bb01464cf0d7a43073924db216a5d043b619d26dbdfbd4cd27ae896e8)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument _from_stack", value=_from_stack, expected_type=type_hints["_from_stack"])
        return typing.cast(TerraformRemoteState, jsii.invoke(self, "getRemoteStateDataSource", [scope, name, _from_stack]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))


class SwiftBackend(
    TerraformBackend,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdktn.SwiftBackend",
):
    '''
    :deprecated: CDK for Terraform no longer supports the swift backend. Terraform deprecated swift in v1.2.3 and removed it in v1.3.

    :stability: deprecated
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        *,
        container: builtins.str,
        application_credential_id: typing.Optional[builtins.str] = None,
        application_credential_name: typing.Optional[builtins.str] = None,
        application_credential_secret: typing.Optional[builtins.str] = None,
        archive_container: typing.Optional[builtins.str] = None,
        auth_url: typing.Optional[builtins.str] = None,
        cacert_file: typing.Optional[builtins.str] = None,
        cert: typing.Optional[builtins.str] = None,
        cloud: typing.Optional[builtins.str] = None,
        default_domain: typing.Optional[builtins.str] = None,
        domain_id: typing.Optional[builtins.str] = None,
        domain_name: typing.Optional[builtins.str] = None,
        expire_after: typing.Optional[builtins.str] = None,
        insecure: typing.Optional[builtins.bool] = None,
        key: typing.Optional[builtins.str] = None,
        password: typing.Optional[builtins.str] = None,
        project_domain_id: typing.Optional[builtins.str] = None,
        project_domain_name: typing.Optional[builtins.str] = None,
        region_name: typing.Optional[builtins.str] = None,
        state_name: typing.Optional[builtins.str] = None,
        tenant_id: typing.Optional[builtins.str] = None,
        tenant_name: typing.Optional[builtins.str] = None,
        token: typing.Optional[builtins.str] = None,
        user_domain_id: typing.Optional[builtins.str] = None,
        user_domain_name: typing.Optional[builtins.str] = None,
        user_id: typing.Optional[builtins.str] = None,
        user_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param container: 
        :param application_credential_id: 
        :param application_credential_name: 
        :param application_credential_secret: 
        :param archive_container: 
        :param auth_url: 
        :param cacert_file: 
        :param cert: 
        :param cloud: 
        :param default_domain: 
        :param domain_id: 
        :param domain_name: 
        :param expire_after: 
        :param insecure: 
        :param key: 
        :param password: 
        :param project_domain_id: 
        :param project_domain_name: 
        :param region_name: 
        :param state_name: 
        :param tenant_id: 
        :param tenant_name: 
        :param token: 
        :param user_domain_id: 
        :param user_domain_name: 
        :param user_id: 
        :param user_name: 

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__654caed6ba682d70ac0511d2cb9c3c6ffc8cd66bebdf8340f225574e23509a99)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = SwiftBackendConfig(
            container=container,
            application_credential_id=application_credential_id,
            application_credential_name=application_credential_name,
            application_credential_secret=application_credential_secret,
            archive_container=archive_container,
            auth_url=auth_url,
            cacert_file=cacert_file,
            cert=cert,
            cloud=cloud,
            default_domain=default_domain,
            domain_id=domain_id,
            domain_name=domain_name,
            expire_after=expire_after,
            insecure=insecure,
            key=key,
            password=password,
            project_domain_id=project_domain_id,
            project_domain_name=project_domain_name,
            region_name=region_name,
            state_name=state_name,
            tenant_id=tenant_id,
            tenant_name=tenant_name,
            token=token,
            user_domain_id=user_domain_id,
            user_domain_name=user_domain_name,
            user_id=user_id,
            user_name=user_name,
        )

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

    @jsii.member(jsii_name="getRemoteStateDataSource")
    def get_remote_state_data_source(
        self,
        scope: _constructs_77d1e7e8.Construct,
        name: builtins.str,
        _from_stack: builtins.str,
    ) -> TerraformRemoteState:
        '''(deprecated) Creates a TerraformRemoteState resource that accesses this backend.

        :param scope: -
        :param name: -
        :param _from_stack: -

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__110786b9093e65c86e4119991a812b63af9aa024c2a4595d41ac4d71003c1789)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument _from_stack", value=_from_stack, expected_type=type_hints["_from_stack"])
        return typing.cast(TerraformRemoteState, jsii.invoke(self, "getRemoteStateDataSource", [scope, name, _from_stack]))

    @jsii.member(jsii_name="synthesizeAttributes")
    def _synthesize_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: deprecated
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeAttributes", []))

    @jsii.member(jsii_name="synthesizeHclAttributes")
    def _synthesize_hcl_attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: deprecated
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "synthesizeHclAttributes", []))


@jsii.data_type(
    jsii_type="cdktn.TerraformHclModuleConfig",
    jsii_struct_bases=[TerraformModuleConfig],
    name_mapping={
        "depends_on": "dependsOn",
        "for_each": "forEach",
        "providers": "providers",
        "skip_asset_creation_from_local_modules": "skipAssetCreationFromLocalModules",
        "source": "source",
        "version": "version",
        "variables": "variables",
    },
)
class TerraformHclModuleConfig(TerraformModuleConfig):
    def __init__(
        self,
        *,
        depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
        for_each: typing.Optional[ITerraformIterator] = None,
        providers: typing.Optional[typing.Sequence[typing.Union[TerraformProvider, typing.Union[TerraformModuleProvider, typing.Dict[builtins.str, typing.Any]]]]] = None,
        skip_asset_creation_from_local_modules: typing.Optional[builtins.bool] = None,
        source: builtins.str,
        version: typing.Optional[builtins.str] = None,
        variables: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    ) -> None:
        '''
        :param depends_on: 
        :param for_each: 
        :param providers: 
        :param skip_asset_creation_from_local_modules: 
        :param source: 
        :param version: 
        :param variables: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0930e68f78776f6767a34b896806a2c7f0841f069ff5f5b3f5b121addd24e2d3)
            check_type(argname="argument depends_on", value=depends_on, expected_type=type_hints["depends_on"])
            check_type(argname="argument for_each", value=for_each, expected_type=type_hints["for_each"])
            check_type(argname="argument providers", value=providers, expected_type=type_hints["providers"])
            check_type(argname="argument skip_asset_creation_from_local_modules", value=skip_asset_creation_from_local_modules, expected_type=type_hints["skip_asset_creation_from_local_modules"])
            check_type(argname="argument source", value=source, expected_type=type_hints["source"])
            check_type(argname="argument version", value=version, expected_type=type_hints["version"])
            check_type(argname="argument variables", value=variables, expected_type=type_hints["variables"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "source": source,
        }
        if depends_on is not None:
            self._values["depends_on"] = depends_on
        if for_each is not None:
            self._values["for_each"] = for_each
        if providers is not None:
            self._values["providers"] = providers
        if skip_asset_creation_from_local_modules is not None:
            self._values["skip_asset_creation_from_local_modules"] = skip_asset_creation_from_local_modules
        if version is not None:
            self._values["version"] = version
        if variables is not None:
            self._values["variables"] = variables

    @builtins.property
    def depends_on(self) -> typing.Optional[typing.List[ITerraformDependable]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("depends_on")
        return typing.cast(typing.Optional[typing.List[ITerraformDependable]], result)

    @builtins.property
    def for_each(self) -> typing.Optional[ITerraformIterator]:
        '''
        :stability: experimental
        '''
        result = self._values.get("for_each")
        return typing.cast(typing.Optional[ITerraformIterator], result)

    @builtins.property
    def providers(
        self,
    ) -> typing.Optional[typing.List[typing.Union[TerraformProvider, TerraformModuleProvider]]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("providers")
        return typing.cast(typing.Optional[typing.List[typing.Union[TerraformProvider, TerraformModuleProvider]]], result)

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

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

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

    @builtins.property
    def variables(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("variables")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], 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 "TerraformHclModuleConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


__all__ = [
    "AnnotationMetadataEntryType",
    "Annotations",
    "AnyListList",
    "AnyListMap",
    "AnyMap",
    "AnyMapList",
    "App",
    "AppConfig",
    "Aspects",
    "AssetType",
    "AzurermBackend",
    "AzurermBackendConfig",
    "BooleanList",
    "BooleanListList",
    "BooleanListMap",
    "BooleanMap",
    "BooleanMapList",
    "CloudBackend",
    "CloudBackendConfig",
    "CloudWorkspace",
    "ComplexComputedList",
    "ComplexList",
    "ComplexMap",
    "ComplexObject",
    "ConsulBackend",
    "ConsulBackendConfig",
    "CosBackend",
    "CosBackendAssumeRole",
    "CosBackendConfig",
    "DataConfig",
    "DataResource",
    "DataTerraformRemoteState",
    "DataTerraformRemoteStateAzurerm",
    "DataTerraformRemoteStateAzurermConfig",
    "DataTerraformRemoteStateConfig",
    "DataTerraformRemoteStateConsul",
    "DataTerraformRemoteStateConsulConfig",
    "DataTerraformRemoteStateCos",
    "DataTerraformRemoteStateCosConfig",
    "DataTerraformRemoteStateGcs",
    "DataTerraformRemoteStateGcsConfig",
    "DataTerraformRemoteStateHttp",
    "DataTerraformRemoteStateHttpConfig",
    "DataTerraformRemoteStateLocal",
    "DataTerraformRemoteStateLocalConfig",
    "DataTerraformRemoteStateOss",
    "DataTerraformRemoteStateOssConfig",
    "DataTerraformRemoteStatePg",
    "DataTerraformRemoteStatePgConfig",
    "DataTerraformRemoteStateRemoteConfig",
    "DataTerraformRemoteStateS3",
    "DataTerraformRemoteStateS3Config",
    "DataTerraformRemoteStateSwift",
    "DataTerraformRemoteStateSwiftConfig",
    "DefaultTokenResolver",
    "DynamicListTerraformIterator",
    "EncodingOptions",
    "FileProvisioner",
    "Fn",
    "FnGenerated",
    "GcsBackend",
    "GcsBackendConfig",
    "HttpBackend",
    "HttpBackendConfig",
    "IAnyProducer",
    "IAspect",
    "IFragmentConcatenator",
    "IImportableConfig",
    "IInterpolatingParent",
    "IListProducer",
    "IManifest",
    "INumberProducer",
    "IPostProcessor",
    "IRemoteWorkspace",
    "IResolvable",
    "IResolveContext",
    "IResource",
    "IResourceConstructor",
    "IScopeCallback",
    "IStackSynthesizer",
    "IStringProducer",
    "ISynthesisSession",
    "ITerraformAddressable",
    "ITerraformDependable",
    "ITerraformIterator",
    "ITerraformResource",
    "ITokenMapper",
    "ITokenResolver",
    "ImportableResource",
    "Lazy",
    "LazyAnyValueOptions",
    "LazyBase",
    "LazyListValueOptions",
    "LazyStringValueOptions",
    "ListTerraformIterator",
    "LocalBackend",
    "LocalBackendConfig",
    "LocalExecProvisioner",
    "Manifest",
    "MapList",
    "MapTerraformIterator",
    "MigrateIds",
    "NamedCloudWorkspace",
    "NamedRemoteWorkspace",
    "NumberListList",
    "NumberListMap",
    "NumberMap",
    "NumberMapList",
    "Op",
    "OssAssumeRole",
    "OssBackend",
    "OssBackendConfig",
    "PgBackend",
    "PgBackendConfig",
    "Postcondition",
    "Precondition",
    "PrefixedRemoteWorkspaces",
    "RemoteBackend",
    "RemoteBackendConfig",
    "RemoteExecProvisioner",
    "ResolveOptions",
    "Resource",
    "ResourceTerraformIterator",
    "S3Backend",
    "S3BackendAssumeRoleConfig",
    "S3BackendAssumeRoleWithWebIdentityConfig",
    "S3BackendConfig",
    "S3BackendEndpointConfig",
    "SSHProvisionerConnection",
    "StackAnnotation",
    "StackManifest",
    "StringConcat",
    "StringListList",
    "StringListMap",
    "StringMap",
    "StringMapList",
    "SwiftBackend",
    "SwiftBackendConfig",
    "TaggedCloudWorkspaces",
    "TerraformAsset",
    "TerraformAssetConfig",
    "TerraformBackend",
    "TerraformCondition",
    "TerraformCount",
    "TerraformDataSource",
    "TerraformElement",
    "TerraformElementMetadata",
    "TerraformHclModule",
    "TerraformHclModuleConfig",
    "TerraformIterator",
    "TerraformLocal",
    "TerraformMetaArguments",
    "TerraformModule",
    "TerraformModuleConfig",
    "TerraformModuleProvider",
    "TerraformModuleUserConfig",
    "TerraformOutput",
    "TerraformOutputConfig",
    "TerraformProvider",
    "TerraformProviderConfig",
    "TerraformProviderGeneratorMetadata",
    "TerraformRemoteState",
    "TerraformResource",
    "TerraformResourceConfig",
    "TerraformResourceImport",
    "TerraformResourceLifecycle",
    "TerraformResourceMoveById",
    "TerraformResourceMoveByTarget",
    "TerraformResourceTargets",
    "TerraformSelf",
    "TerraformStack",
    "TerraformStackMetadata",
    "TerraformVariable",
    "TerraformVariableConfig",
    "TerraformVariableValidationConfig",
    "Testing",
    "TestingAppConfig",
    "Token",
    "Tokenization",
    "TokenizedStringFragments",
    "VariableType",
    "WinrmProvisionerConnection",
    "testing_matchers",
]

publication.publish()

# Loading modules to ensure their types are registered with the jsii runtime library
from . import testing_matchers

def _typecheckingstub__e9289bcf783cd208c819c65416434d4b6ca4219669db4a9b1690754ec81a4ecf(
    scope: _constructs_77d1e7e8.IConstruct,
) -> None:
    """Type checking stubs"""
    pass

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

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

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

def _typecheckingstub__314985dd1b13dc7abf8ef28eee56b891d98970cc4da63171c4a05c0aabdc60d5(
    x: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d4161ba5d98212c33f0c6ac4b02b5c4556ed5a8dc06fe4fece1ecf5bdd2f3716(
    construct: _constructs_77d1e7e8.IConstruct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dd508763dcb927776a0d26940fa560b6888c13155aed629e3bea4a03607a10ae(
    from_stack: TerraformStack,
    to_stack: TerraformStack,
    identifier: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6bd0a26ff3825fcbda63244de3c5788ef4d457cab4355fd0a712a04a52599d76(
    *,
    context: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    hcl_output: typing.Optional[builtins.bool] = None,
    outdir: typing.Optional[builtins.str] = None,
    skip_backend_validation: typing.Optional[builtins.bool] = None,
    skip_validation: typing.Optional[builtins.bool] = None,
    stack_traces: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dfd07ada7b3bf297c914923dcb45a605b0e3d9d6c7481783ac2f43a1d0777357(
    scope: _constructs_77d1e7e8.IConstruct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f4f7745c1c48b778a8610436afdd586398143ae353f53728f976f0b2265477ab(
    aspect: IAspect,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__912173407c419eae209032e0ac104680f082bb5aad4825d0e858e8efc0f9fa76(
    *,
    container_name: builtins.str,
    key: builtins.str,
    storage_account_name: builtins.str,
    access_key: typing.Optional[builtins.str] = None,
    client_certificate_password: typing.Optional[builtins.str] = None,
    client_certificate_path: typing.Optional[builtins.str] = None,
    client_id: typing.Optional[builtins.str] = None,
    client_secret: typing.Optional[builtins.str] = None,
    endpoint: typing.Optional[builtins.str] = None,
    environment: typing.Optional[builtins.str] = None,
    metadata_host: typing.Optional[builtins.str] = None,
    msi_endpoint: typing.Optional[builtins.str] = None,
    oidc_request_token: typing.Optional[builtins.str] = None,
    oidc_request_url: typing.Optional[builtins.str] = None,
    oidc_token: typing.Optional[builtins.str] = None,
    oidc_token_file_path: typing.Optional[builtins.str] = None,
    resource_group_name: typing.Optional[builtins.str] = None,
    sas_token: typing.Optional[builtins.str] = None,
    snapshot: typing.Optional[builtins.bool] = None,
    subscription_id: typing.Optional[builtins.str] = None,
    tenant_id: typing.Optional[builtins.str] = None,
    use_azuread_auth: typing.Optional[builtins.bool] = None,
    use_microsoft_graph: typing.Optional[builtins.bool] = None,
    use_msi: typing.Optional[builtins.bool] = None,
    use_oidc: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4c43a277c741c97005cffe2a27390aad01d95fded1b13c16a35f07ccaec84f7a(
    *,
    organization: builtins.str,
    workspaces: typing.Union[NamedCloudWorkspace, TaggedCloudWorkspaces],
    hostname: typing.Optional[builtins.str] = None,
    token: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__baa70c8729c8356212ac489f983efd7c561527ee11bad26a38dd5c66bc2c0362(
    *,
    access_token: builtins.str,
    path: builtins.str,
    address: typing.Optional[builtins.str] = None,
    ca_file: typing.Optional[builtins.str] = None,
    cert_file: typing.Optional[builtins.str] = None,
    datacenter: typing.Optional[builtins.str] = None,
    gzip: typing.Optional[builtins.bool] = None,
    http_auth: typing.Optional[builtins.str] = None,
    key_file: typing.Optional[builtins.str] = None,
    lock: typing.Optional[builtins.bool] = None,
    scheme: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__81c9621f790496ec286371d0b5f290fcdeda375a3069aef5e6afc305d6a2b73f(
    *,
    role_arn: builtins.str,
    session_duration: jsii.Number,
    session_name: builtins.str,
    policy: typing.Any = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__67a315d21c300ce89cca4c20447408680c7216a2221cf4a7f33b35c6f0294cbe(
    *,
    bucket: builtins.str,
    accelerate: typing.Optional[builtins.bool] = None,
    acl: typing.Optional[builtins.str] = None,
    assume_role: typing.Optional[typing.Union[CosBackendAssumeRole, typing.Dict[builtins.str, typing.Any]]] = None,
    domain: typing.Optional[builtins.str] = None,
    encrypt: typing.Optional[builtins.bool] = None,
    endpoint: typing.Optional[builtins.str] = None,
    key: typing.Optional[builtins.str] = None,
    prefix: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    secret_id: typing.Optional[builtins.str] = None,
    secret_key: typing.Optional[builtins.str] = None,
    security_token: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__af2f5933ed8e8293b381c53ae0a863407c84bebdb688791a908756930c5cd04f(
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eabe5784d64b19bb922d018b00dca4e55c987cb9a5dbc553636e0fb9b9b88d02(
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    access_token: builtins.str,
    path: builtins.str,
    address: typing.Optional[builtins.str] = None,
    ca_file: typing.Optional[builtins.str] = None,
    cert_file: typing.Optional[builtins.str] = None,
    datacenter: typing.Optional[builtins.str] = None,
    gzip: typing.Optional[builtins.bool] = None,
    http_auth: typing.Optional[builtins.str] = None,
    key_file: typing.Optional[builtins.str] = None,
    lock: typing.Optional[builtins.bool] = None,
    scheme: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2304a07789ee803e0da927f40176e5d3e1f3c0d59cd9af80ba83c55b982e7603(
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    bucket: builtins.str,
    accelerate: typing.Optional[builtins.bool] = None,
    acl: typing.Optional[builtins.str] = None,
    assume_role: typing.Optional[typing.Union[CosBackendAssumeRole, typing.Dict[builtins.str, typing.Any]]] = None,
    domain: typing.Optional[builtins.str] = None,
    encrypt: typing.Optional[builtins.bool] = None,
    endpoint: typing.Optional[builtins.str] = None,
    key: typing.Optional[builtins.str] = None,
    prefix: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    secret_id: typing.Optional[builtins.str] = None,
    secret_key: typing.Optional[builtins.str] = None,
    security_token: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__ab303a023458b5bb7912501c8cdb6bc5f9cce568e0837095a1be589e9a41d882(
    *,
    destination: builtins.str,
    type: builtins.str,
    connection: typing.Optional[typing.Union[typing.Union[SSHProvisionerConnection, typing.Dict[builtins.str, typing.Any]], typing.Union[WinrmProvisionerConnection, typing.Dict[builtins.str, typing.Any]]]] = None,
    content: typing.Optional[builtins.str] = None,
    source: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9d39df44f39af33a9f138dadfb4600241b9c63fbdf6845d040a55d84abb1d0cc(
    num: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__bff9bc764ddd56233d30866b6e3715a167f1eb1127fe0de24f327a5fe5a8aed2(
    list: typing.Sequence[typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__be8e4a30e9f8a8b02dd66c097fe93102b0c05c75d53e4721e5b86eae1d7c8d98(
    list: typing.Sequence[typing.Any],
) -> None:
    """Type checking stubs"""
    pass

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

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

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

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

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

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

def _typecheckingstub__f8ac795e94d3de88324d8a9c5e34884489d6db2e3ebd156cae240bec26f28d5e(
    expression: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e72f66889a8998809228fb82f8d1850c8a21d4a9c64a6c0f7020fdd4f1c4a67a(
    num: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__ce0af7ebdc0cf508f7928458989ada25777d413bb900b9f7da33fe5640afd874(
    list: typing.Sequence[typing.Any],
    size: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__529619d82d9f1147d808de320e57f4fbd7d322ff30fd9349288f46f6354d7e7a(
    prefix: builtins.str,
    hostnum: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__8053cd40b5a4b7afeab73a145662f234239aa829327ed523d937ac3766ac1a0f(
    prefix: builtins.str,
    newbits: jsii.Number,
    netnum: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__57b4782f64537c6c60365d594695e57257e2a7d4179a43b6fce8f7ec298bc4fa(
    prefix: builtins.str,
    newbits: typing.Sequence[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1fb3aef9d4b76771241df5534ce91e1875f197b03be98c3f14d6445f3a23cdeb(
    vals: typing.Sequence[typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b04b60da3fa9a1a3437c8fc0acc8588649e4444cf3dea4ea414ceb0d0a79206f(
    vals: typing.Sequence[typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__313e8bb907f8b59977e0e1bf117718fddc5fcaf1085486c36a4c392e3b10be1b(
    list: typing.Sequence[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e4c76fb1459acafc104bd4d08fee28d38cc6a487c1950b0c082b335d664ca3a6(
    seqs: typing.Sequence[typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8bae3d846a2a830f67633e81cda0cf30b6b748e96e0633452450cd441f43a664(
    list: typing.Any,
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

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

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

def _typecheckingstub__e2822c87a26275696b738df1a2af7802c9c6d767bb81f79d2f6296bb9c3c059d(
    list: typing.Sequence[typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__07d8f09b529f219ed3912d33fd482f5ff7e7b71765b8b6b48f26e85f0932139d(
    list: typing.Any,
    index: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

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

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

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

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

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

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

def _typecheckingstub__c845652bb5feafb3f21b971d5630d20d055362918c70686bdf734e224b8c6548(
    path: builtins.str,
    pattern: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

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

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

def _typecheckingstub__a459f1ca7ee45011b65c6d94168428f66add3e2ae90af5e7dca1ee018d71f199(
    list: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8d933dd9227ba0b3dbd79c9278eb9c0e5ba99a05487e194954a30947e3f2395b(
    num: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2000666ae0491b73893edc10d30e7d1c728288102936b3bee9b0d95d1f4982ab(
    format: builtins.str,
    args: typing.Sequence[typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__61072dada83bcad8479193ae443000262d05d69dfab8a2bbe87695072d3623e4(
    format: builtins.str,
    time: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__973e0cee58d04843b1ec115811f7414596cb1cde6d39cdb210930386e2790a97(
    format: builtins.str,
    args: typing.Sequence[typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__71f3ca7e1863451b977fbb3109b938b7499bda67954b0ac6ccb2a3e98771199f(
    spaces: jsii.Number,
    str: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a31158cedb446b33ec6f3c3dac38a9ec7b93b1afe0bca7558a29c67b6ad9b492(
    list: typing.Any,
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__ea20d6d2d6132cb371ed5e95069019e3b4d40a347495bb54c035981b027a1d87(
    val: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__29fb631cced10ad8a27db65a69a22c9cd494e10a9064e2c450a12f2583d13c80(
    input_map: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__052ed58651630e3f0096ca11dc790d6eb6c6d16086cec4df2693eda0b5e67f1f(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d347f3e24a82f256e95a4a7130bbde6ea7054b8da91a367bec8c368054b0c13f(
    num: jsii.Number,
    base: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__72fa40d9c8291cef8c5c0c116db9d1d8fbaa1dbfe3bb272f64e90eda4eab93c6(
    values: typing.Sequence[typing.Any],
    keys: typing.Sequence[typing.Any],
    searchset: typing.Sequence[typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4a7a3d3fee4cf879671a99e076b6d8daabd4834ce73543a594d04d87082fe11c(
    numbers: typing.Sequence[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__875d410edf57046cddd39cbc1d66c4fbadb3ff8e5c68486f3be0707d658320ec(
    maps: typing.Sequence[typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__03cf066cdfb04be5ee0e87ad28b4622b7b653fd9f256f03fc8b9fa5ed680b42b(
    numbers: typing.Sequence[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f54e546910dc0fa0068231339fdd41f1dfe84ebd31c205953e0c5146803d135f(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aff1345cc20e64d27d35157843e3b68c36a543546699881ef8a251ea4b1f5192(
    list: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8dd4adb0e316237678faec6d594f7674a44ba5b5f9a7817e28c8dd7ecb4eb629(
    number: typing.Any,
    base: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__bcf07285e3a0e5740c6f713a638e085085e2d95fa1819660e59fc0ab82b1f4a3(
    num: jsii.Number,
    power: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

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

def _typecheckingstub__e36b1bf54c166721cb1a0fb4234e883551d4f2b91fc6d2dde7b95a5b2b169ebf(
    str: builtins.str,
    substr: builtins.str,
    replace: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__071a1a2d4e74f9a0b01e39f900c50e30f187bf7c2cde92dd81aacfd3f5c059a1(
    list: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__51aa25e5e94a77d383c37dc351212cf58c5b96452abf53a086d2b55dcd869614(
    ciphertext: builtins.str,
    privatekey: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__21955c1965dc21beffcde9636967cc3c71cd154d00a3f0c9575355f3f524ea86(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c9300381230bd7bd03e82d943a4078da740f4e904623f2e86fc03cb8c13a743c(
    first_set: typing.Sequence[typing.Any],
    other_sets: typing.Sequence[typing.Sequence[typing.Any]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f67d797ac1f8be835252f345304c90c8666c043efb3c3c75e22dcaad0d09afac(
    sets: typing.Sequence[typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4c423ebfa20385b5c70e2339eaa3d326bc619db5874a494b0d6bb15f3ee889c3(
    a: typing.Sequence[typing.Any],
    b: typing.Sequence[typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2a0883bd0c8081e52ec7e1744943133e498e6eb78c26b051476c5ea596d3eda3(
    first_set: typing.Sequence[typing.Any],
    other_sets: typing.Sequence[typing.Sequence[typing.Any]],
) -> None:
    """Type checking stubs"""
    pass

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

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

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

def _typecheckingstub__3c9b47c61fe0e3f3ba2c50f3658aa0b64720c6ab5300b336cdc33f0f80a4a127(
    num: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dedcdb9decab4e97af9b64a0210f9636f941064061e3fb9b502ac4eb0e045c88(
    list: typing.Any,
    start_index: jsii.Number,
    end_index: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f7e36acfec5bc9d460f5fa9ddedceae511c30827e190e7ef1958fd360bcbdb35(
    list: typing.Sequence[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

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

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

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

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

def _typecheckingstub__7f0fe7553eee1d90b146664a7052e1a686ef5731413210cee080e71c2bcde496(
    str: builtins.str,
    offset: jsii.Number,
    length: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__578d03977d89d801eb6b00c2d8304a5f264fc7727519260dabc97955ef84e1f0(
    list: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c76b176034dbe10e31045d672834717ca0501daadbbace2b4c5ffa844d08d177(
    path: builtins.str,
    vars: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__28abf90d76672e97155cf5ff248550579a78c71ff3d4cee1fbca4198f4defc7a(
    source: builtins.str,
    encoding: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__60c2f89197ef63a964f7f4e82ba947f1f019c6247ddfc0b3d87ea2c0c3f656cf(
    timestamp: builtins.str,
    duration: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5cea677b404ba8e9412f285c10e53a1592e03f76583f42217a4f02e99b179b96(
    timestamp_a: builtins.str,
    timestamp_b: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__af6b9742f4403945bc453d4ec774ec5a4b9f5d53ffe858c7b88f11ccaae51e72(
    v: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aa8b4a57bcd7143102adc630590a92c4f0e1a1b8eda4145158d49fc26bc4e610(
    v: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bd0d67bafe08c9d6a38f74c18c9f2cf3c719ef138e159cf30efe1b66f03dc367(
    v: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e8d252bb074e93a0c98e75eded6408f6e10c18555cf591aa8acb7ae5787d818c(
    v: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2e43cf8f2cd5811b47d41854740d07ec75cf3cfb647aab349a0e94ec0f8fee74(
    v: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f7563a1cfb6f5d7950d7e696eb3ecb049e3bce4b81e098bb90a50c2f45dee096(
    v: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3a129153461637c6ac54a32c2a34b3157c1181b7b81769d02d7f2e443f29d5f5(
    values: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

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

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

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

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

def _typecheckingstub__b1b0fc999f2a74d44252ee1bc8191ac093000ed90ad242fac8f4fda196c99b90(
    expressions: typing.Sequence[typing.Any],
) -> None:
    """Type checking stubs"""
    pass

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

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

def _typecheckingstub__96253411071bb1f272728a3f979081141c86ac677678a384ac90aefa3b4efb8a(
    namespace: builtins.str,
    name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__365b008528a9cb882ccaead2eb8550f2d4c79113cb4da255b503ce7d9b5d3d63(
    mapping: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__57d6054065cf9462ecc201f28a1dcd237a59bb628840b2550f1949d18b730081(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bbcc6b00a995ef837f0edbe6c4d470e02ebf769530fb34f9e2ebe9ee8a29d6df(
    keys: typing.Sequence[builtins.str],
    values: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__02a007eb5d844cb755597f8f7b398f7a3f7609266be039a95f1a2ef859932394(
    *,
    bucket: builtins.str,
    access_token: typing.Optional[builtins.str] = None,
    credentials: typing.Optional[builtins.str] = None,
    encryption_key: typing.Optional[builtins.str] = None,
    impersonate_service_account: typing.Optional[builtins.str] = None,
    impersonate_service_account_delegates: typing.Optional[typing.Sequence[builtins.str]] = None,
    kms_encryption_key: typing.Optional[builtins.str] = None,
    prefix: typing.Optional[builtins.str] = None,
    storeage_custom_endpoint: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__27729e4a0abd45031476ee90b812455ae6ea91f9c86638a8632a9d1299e23f8f(
    *,
    address: builtins.str,
    client_ca_certificate_pem: typing.Optional[builtins.str] = None,
    client_certificate_pem: typing.Optional[builtins.str] = None,
    client_private_key_pem: typing.Optional[builtins.str] = None,
    lock_address: typing.Optional[builtins.str] = None,
    lock_method: typing.Optional[builtins.str] = None,
    password: typing.Optional[builtins.str] = None,
    retry_max: typing.Optional[jsii.Number] = None,
    retry_wait_max: typing.Optional[jsii.Number] = None,
    retry_wait_min: typing.Optional[jsii.Number] = None,
    skip_cert_verification: typing.Optional[builtins.bool] = None,
    unlock_address: typing.Optional[builtins.str] = None,
    unlock_method: typing.Optional[builtins.str] = None,
    update_method: typing.Optional[builtins.str] = None,
    username: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4a0159196c8851281f3a72f27e861c856b6edfa3fd9095efa5c3f4c1b630ae0e(
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__48fc437143c216b0e0b12970decc48ef59cf9c66c38c3b9962300ce64173a576(
    node: _constructs_77d1e7e8.IConstruct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0524e3980277b204376778b01f8296df52f017fa2aa7cac9d5ee6ccc7e021fd1(
    left: typing.Any,
    right: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

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

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

def _typecheckingstub__95ec7c9877f9d693fda9f27623c78055503ed51d9c56aa428aeb9dbffaac1d24(
    value: typing.Optional[TerraformProvider],
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__edc2bbaa50791d52a25063eb84845c7f5999fb858ed25087ddec25b6d102379d(
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__040fbbe6cd0b7cfbe51648e9927449cc679660cc7334a61c040885300504af53(
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3fc42f67c6b31440605d9f916eb60e940d0723e624db6dd5ce92e30e2a945c69(
    input: typing.Any,
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6a79ef13a5b5036324b5f0638eb1c8d081b851b71d41cdf54e067d400f7ac2c2(
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bdd4f993495df4928ff25e2d62d50a0eaf71d254f991494e821acc8847ac7381(
    value: typing.Optional[builtins.bool],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__224ad1fad2cc9448fafe9c54ba4fcf2d0d30df4dbc92af846f48f04aafb13349(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__57649b2d58965efe4844ab6a3583cfe01431a6274584587137289ce9bb1fff6e(
    value: typing.Optional[builtins.bool],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4e9c13b1984c45331bc843de344702265200444960f35c556580b709623aec48(
    value: typing.Optional[builtins.bool],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__993f9296c0043965e1f85c9ecdb8f793f903ef8df809f312f112270f513ecbce(
    post_processor: IPostProcessor,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__066083df2ae2796466adee5089cc3f9e46c260e720ca7739b4c01436b9337d84(
    x: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cd901f3fac7761cfe229a9a81dc57cb71f9ec36ce72d192a6975c8842fabaa38(
    session: ISynthesisSession,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6106609dc86be8b07a9c4296893563288e0d42e1c5ecd1dfc631d873db928cfc(
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1f88c5e74e7a2aec7c6c2e71ceb318f090fcbbbaf994a55d028e400c7f8cf32e(
    value: typing.Optional[typing.Union[jsii.Number, TerraformCount]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fd3898a06d3445ff371de5e6106379c8a35d564bb652f2db604419a1ff63217f(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7af7a11f65f4cb9ffb382849484dfd007dbb7982fec3f92c522618a09cd92068(
    value: typing.Optional[ITerraformIterator],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__449f726c15bdb834959dbb3bdd9d72d14042d3dfdbb8410e4d4e53847de30830(
    value: typing.Optional[TerraformResourceLifecycle],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9327104b240661670ab7a7ef35952749a791e542d12541bfb9ea693c6ec3431d(
    value: typing.Optional[TerraformProvider],
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__dc0625f97a2f3fdf7324333a6e918fafbb8ac6e546aed97e6648ae7207123413(
    t: IResolvable,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e5c536b94a6ecf79f0fff22e16888e164f773a472065adb487d585c3bcdf1a50(
    l: typing.Sequence[builtins.str],
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__77c936c22797fdbb8202d7dafdd309b4415f746374e701c8542f4b108d145b18(
    m: typing.Mapping[builtins.str, typing.Any],
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a1060a7520326b72460b776e4a7f0c3ac663ab99601334dd0236182c3ec12b8e(
    l: typing.Sequence[jsii.Number],
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__71a6271008e6a9d7c10d7bd3fcb94d7d1179cb97ef723d31e047e514bbe35cf9(
    s: TokenizedStringFragments,
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__446ac9cdf660783f83d823168622856e6e30e8cf8f9d6fd5e284ebabaab43b56(
    t: IResolvable,
    context: IResolveContext,
    post_processor: IPostProcessor,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2fa40fb53d29e55c7fbdf687d5ff05a4cbea41475d41ac17521f5b945e2c8100(
    producer: IAnyProducer,
    *,
    display_hint: typing.Optional[builtins.str] = None,
    omit_empty_array: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c1628b41b89cb0fed2f7a962ac64b2ee841aebd1d5b366b83b72e9a8acdb5761(
    producer: IListProducer,
    *,
    display_hint: typing.Optional[builtins.str] = None,
    omit_empty: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4f9529a83825302681de0dcf814c2af4992aa88a16eaeb5828a2ebcc8949c1d3(
    producer: INumberProducer,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6e8e7689ad601e12458421f1de501fd89035a0de334c0ee8cc69dfcbc20315d5(
    producer: IStringProducer,
    *,
    display_hint: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__724a09d1f6f0577cb0e49102f3754314c5515a6f688cd9cf37c096ec38c62f02(
    *,
    display_hint: typing.Optional[builtins.str] = None,
    omit_empty_array: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__14d71377dbabf13e214c9e8b4656bade2b43b4d30282a33022fcb3f0dcc6cc16(
    post_processor: IPostProcessor,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__32b3351131ca410b5ced13b0320d80f6e804696a0eaca4b014bd39e950eff76e(
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7af5f701b7ad0b9c3858ed3ec169ccf8859f8bc6637aec85795667a95f742d6d(
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__862feef5a838adce4ca3ddb313a3e415d4ce42bd11e0b5bededdb0985828921f(
    *,
    display_hint: typing.Optional[builtins.str] = None,
    omit_empty: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__a0560c43ba6a1dbd8ccca9d33d5cee94a0cd48d16c401cfbec0ca24f8a8774ca(
    *,
    path: typing.Optional[builtins.str] = None,
    workspace_dir: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__274d7acb56d992610a2be6e73e1b00653a6d50ed77f35e5eb8087bf328e67524(
    *,
    command: builtins.str,
    type: builtins.str,
    environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    interpreter: typing.Optional[typing.Sequence[builtins.str]] = None,
    when: typing.Optional[builtins.str] = None,
    working_dir: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__61f6d0469d8a367e30ba46537674c806255ade18719e532dca077ce226a2595d(
    version: builtins.str,
    outdir: builtins.str,
    hcl_output: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f43a9c35e0a86216f72804bf74a1bd2b23c9cf31747602192add7a287a17838d(
    stack: TerraformStack,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a44f61bb976c94a555c28732af02f8dd8cf5e34c08cc877f857bf8153fbf84e0(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
    wraps_set: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__f1552b80262f33f55bf46b82fc83331effd55432fdcfae4d6fb0348ef40bf0ff(
    _context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__67251ac281cd3c9c48591ad90a1b5d01abd8b0a2f294035ebb9cb79939d0c091(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__53d7e392884d6103e9041687abac691ce226fee1fb7ebc63310618fb9cd437ec(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cb56592fc00188e61a552c37329aaad2d0e77ac93599cd68307a7b3ed441c155(
    node: _constructs_77d1e7e8.IConstruct,
) -> None:
    """Type checking stubs"""
    pass

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

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

def _typecheckingstub__cdacbeb6ab99146be3200a01d29ab2509ac627c74aa1a04efa77379880d67a05(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

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

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

def _typecheckingstub__214c52e45b9070883422d9ab2eed19969eac6baad0f53b505d3f338a8c0f21b5(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__a48edbb8f705597cd1085cd16864d64daee8e41258613abfa5a31fe730552964(
    _context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__98f5b920e232a14df9946b19e49702229a6f30591827bad88bba73e1b5e89931(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5652f791e9c89cf42150d84ee43d36102e5d321a3bf3f238a94b76b0d9df7d73(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
    wraps_set: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5ebc3bc91d5183eb5087cd625f294385478fbaea207628220638a827157827cd(
    index: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__5af1a83a5600895192f5ff912d1975637bf5b650f71b53944020bbe62470163b(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2945ad0a64e5aa1fc06c37386342cf289a06aa4bcd3c2819e7510b55430c1924(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c89edc54c51fd737011d0d1d16c08b61d2d36e8e723f680c851e7f7b5082579c(
    left: typing.Any,
    right: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__184aa448229db7afe11b1a2eacdadd2a88850fb73e904ee9d3e4a6b97afc13b9(
    left: typing.Any,
    right: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8442861840951769d42c33d424f8ac28b3446902528ed56b9aa55bf111e93599(
    left: typing.Any,
    right: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a9dd7597581ee2c12f3fc8eeeecab5194b083af2e13a7ef3e335dd7e3b1e2f61(
    left: typing.Any,
    right: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__62289b2450824c237c7b05d69a5a90899f19717b691a25e8b3b10a335fdf16a5(
    left: typing.Any,
    right: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a6c081e3cbad3a06417949424078cdd63771674b9d079ebb3dcb842d2556204b(
    left: typing.Any,
    right: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__82bb1cd58e2da117736da1c4ab6e18d17e48b076a4fb3644ccfe1b091e99f2db(
    left: typing.Any,
    right: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0e09d20865f5c227c4627b6936694ec23b3e2f824d4df94f745ecf38a65338c4(
    left: typing.Any,
    right: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fde028c9b08af653c189c5ae2ce62378877da4e30888d67b2433117bfd8c1879(
    left: typing.Any,
    right: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1000f75d6be97dfeb93725dd0d72d8831e6f765e304c9f3d35a9a8d204b8a88c(
    left: typing.Any,
    right: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6f5fb9218c93366387cdb3196c4011f7811eedc244d46e96bdbe32469b59d6db(
    expression: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8dd05cd9ce567fa939232f41d126312b87cfab33709bb65577362099483ed769(
    left: typing.Any,
    right: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9250ff5d0d2f42d801de36d35382f5dce7f85e1131f3897d769594ef76f198e4(
    expression: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__367888dc27094c2253e94bbe0bd3a4b42c9fe599ddd447acfa75591e8ef38e15(
    left: typing.Any,
    right: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__932d8b82493b130202229f6b4ac14fe2afa8cf77bf5420a78b2ead74aac8e5c1(
    left: typing.Any,
    right: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4ab9e5a718449fadbc8d3a3cf0ff1879e5303ea69fc5de45d97982a12ca61ced(
    *,
    role_arn: builtins.str,
    policy: typing.Optional[builtins.str] = None,
    session_expiration: typing.Optional[jsii.Number] = None,
    session_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3f73f68ebdb166b82b289eec56d99510aa006cdf1bb0518dc28aefc44d49ff4a(
    *,
    bucket: builtins.str,
    access_key: typing.Optional[builtins.str] = None,
    acl: typing.Optional[builtins.str] = None,
    assume_role: typing.Optional[typing.Union[OssAssumeRole, typing.Dict[builtins.str, typing.Any]]] = None,
    assume_role_policy: typing.Optional[builtins.str] = None,
    assume_role_role_arn: typing.Optional[builtins.str] = None,
    assume_role_session_expiration: typing.Optional[jsii.Number] = None,
    assume_role_session_name: typing.Optional[builtins.str] = None,
    ecs_role_name: typing.Optional[builtins.str] = None,
    encrypt: typing.Optional[builtins.bool] = None,
    endpoint: typing.Optional[builtins.str] = None,
    key: typing.Optional[builtins.str] = None,
    prefix: typing.Optional[builtins.str] = None,
    profile: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    secret_key: typing.Optional[builtins.str] = None,
    security_token: typing.Optional[builtins.str] = None,
    shared_credentials_file: typing.Optional[builtins.str] = None,
    sts_endpoint: typing.Optional[builtins.str] = None,
    tablestore_endpoint: typing.Optional[builtins.str] = None,
    tablestore_table: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7030236e50c7b9284053ddfef788c040111f5242244cef912dfd6669ff1a3517(
    *,
    conn_str: builtins.str,
    schema_name: typing.Optional[builtins.str] = None,
    skip_index_creation: typing.Optional[builtins.bool] = None,
    skip_schema_creation: typing.Optional[builtins.bool] = None,
    skip_table_creation: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

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

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

def _typecheckingstub__5dbbfda7a87092b423bd7fff1db9557e142f36d1dfc46f423f9a29a94ac582e7(
    *,
    organization: builtins.str,
    workspaces: IRemoteWorkspace,
    hostname: typing.Optional[builtins.str] = None,
    token: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ecc14f28894fb6b625d68e40edc32b1e948e36b69cd69b665db95b75fce83a59(
    *,
    type: builtins.str,
    connection: typing.Optional[typing.Union[typing.Union[SSHProvisionerConnection, typing.Dict[builtins.str, typing.Any]], typing.Union[WinrmProvisionerConnection, typing.Dict[builtins.str, typing.Any]]]] = None,
    inline: typing.Optional[typing.Sequence[builtins.str]] = None,
    script: typing.Optional[builtins.str] = None,
    scripts: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c877f2c55ac3ed4cc385f946ff7b4d63535735c582a7c62c0f0748faf1dcff8e(
    *,
    resolver: ITokenResolver,
    scope: _constructs_77d1e7e8.IConstruct,
    preparing: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__35e74dd98299db0cd1e159e20557edf5c3ee11baf42aca7e55714a29c00c29e9(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f5dd405820bfc7d96d04fd9d3eb9ead67c37a0307f4714394fff5a774c892cb5(
    *,
    role_arn: builtins.str,
    duration: typing.Optional[builtins.str] = None,
    external_id: typing.Optional[builtins.str] = None,
    policy: typing.Optional[builtins.str] = None,
    policy_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
    session_name: typing.Optional[builtins.str] = None,
    source_identity: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    transitive_tag_keys: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__32c00439efde8bbe4e42d68097b869b0426dcbdac67c39fdc7c2d0796d272d7b(
    *,
    duration: typing.Optional[builtins.str] = None,
    policy: typing.Optional[builtins.str] = None,
    policy_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
    role_arn: typing.Optional[builtins.str] = None,
    session_name: typing.Optional[builtins.str] = None,
    web_identity_token: typing.Optional[builtins.str] = None,
    web_identity_token_file: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9aec09d69e709cce0e4c77ccc2be547a1cfcf4aa8a006a9192483c7aee5b156d(
    *,
    bucket: builtins.str,
    key: builtins.str,
    access_key: typing.Optional[builtins.str] = None,
    acl: typing.Optional[builtins.str] = None,
    allowed_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    assume_role: typing.Optional[typing.Union[S3BackendAssumeRoleConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    assume_role_policy: typing.Optional[builtins.str] = None,
    assume_role_policy_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
    assume_role_tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    assume_role_transitive_tag_keys: typing.Optional[typing.Sequence[builtins.str]] = None,
    assume_role_with_web_identity: typing.Optional[typing.Union[S3BackendAssumeRoleWithWebIdentityConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    custom_ca_bundle: typing.Optional[builtins.str] = None,
    dynamodb_endpoint: typing.Optional[builtins.str] = None,
    dynamodb_table: typing.Optional[builtins.str] = None,
    ec2_metadata_service_endpoint: typing.Optional[builtins.str] = None,
    ec2_metadata_service_endpoint_mode: typing.Optional[builtins.str] = None,
    encrypt: typing.Optional[builtins.bool] = None,
    endpoint: typing.Optional[builtins.str] = None,
    endpoints: typing.Optional[typing.Union[S3BackendEndpointConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    external_id: typing.Optional[builtins.str] = None,
    forbidden_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    force_path_style: typing.Optional[builtins.bool] = None,
    http_proxy: typing.Optional[builtins.str] = None,
    https_proxy: typing.Optional[builtins.str] = None,
    iam_endpoint: typing.Optional[builtins.str] = None,
    insecure: typing.Optional[builtins.bool] = None,
    kms_key_id: typing.Optional[builtins.str] = None,
    max_retries: typing.Optional[jsii.Number] = None,
    no_proxy: typing.Optional[builtins.str] = None,
    profile: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    retry_mode: typing.Optional[builtins.str] = None,
    role_arn: typing.Optional[builtins.str] = None,
    secret_key: typing.Optional[builtins.str] = None,
    session_name: typing.Optional[builtins.str] = None,
    shared_config_files: typing.Optional[typing.Sequence[builtins.str]] = None,
    shared_credentials_file: typing.Optional[builtins.str] = None,
    shared_credentials_files: typing.Optional[typing.Sequence[builtins.str]] = None,
    skip_credentials_validation: typing.Optional[builtins.bool] = None,
    skip_metadata_api_check: typing.Optional[builtins.bool] = None,
    skip_region_validation: typing.Optional[builtins.bool] = None,
    skip_requesting_account_id: typing.Optional[builtins.bool] = None,
    skip_s3_checksum: typing.Optional[builtins.bool] = None,
    sse_customer_key: typing.Optional[builtins.str] = None,
    sts_endpoint: typing.Optional[builtins.str] = None,
    sts_region: typing.Optional[builtins.str] = None,
    token: typing.Optional[builtins.str] = None,
    use_legacy_workflow: typing.Optional[builtins.bool] = None,
    use_path_style: typing.Optional[builtins.bool] = None,
    workspace_key_prefix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e0fb31f7971cd3bc9a1dff3639c8c469c26120ff2ae90196d3757b79ed5d4e7c(
    *,
    dynamodb: typing.Optional[builtins.str] = None,
    iam: typing.Optional[builtins.str] = None,
    s3: typing.Optional[builtins.str] = None,
    sso: typing.Optional[builtins.str] = None,
    sts: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1fb2f364aa0cd0cb0a71478e84ca35029f533391f3edcf2a9bee5c8b23be16d4(
    *,
    host: builtins.str,
    type: builtins.str,
    agent: typing.Optional[builtins.str] = None,
    agent_identity: typing.Optional[builtins.str] = None,
    bastion_certificate: typing.Optional[builtins.str] = None,
    bastion_host: typing.Optional[builtins.str] = None,
    bastion_host_key: typing.Optional[builtins.str] = None,
    bastion_password: typing.Optional[builtins.str] = None,
    bastion_port: typing.Optional[jsii.Number] = None,
    bastion_private_key: typing.Optional[builtins.str] = None,
    bastion_user: typing.Optional[builtins.str] = None,
    certificate: typing.Optional[builtins.str] = None,
    host_key: typing.Optional[builtins.str] = None,
    password: typing.Optional[builtins.str] = None,
    port: typing.Optional[jsii.Number] = None,
    private_key: typing.Optional[builtins.str] = None,
    proxy_host: typing.Optional[builtins.str] = None,
    proxy_port: typing.Optional[jsii.Number] = None,
    proxy_scheme: typing.Optional[builtins.str] = None,
    proxy_user_name: typing.Optional[builtins.str] = None,
    proxy_user_password: typing.Optional[builtins.str] = None,
    script_path: typing.Optional[builtins.str] = None,
    target_platform: typing.Optional[builtins.str] = None,
    timeout: typing.Optional[builtins.str] = None,
    user: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7d6f2e0c8595375732d0149739981be2e163d3ed76569beae055b49833972195(
    *,
    construct_path: builtins.str,
    level: AnnotationMetadataEntryType,
    message: builtins.str,
    stacktrace: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f174c237fb4d015e64a75ec04a5bb8f4030da2df56f0b3a9ea2ab222a906ce2f(
    *,
    annotations: typing.Sequence[typing.Union[StackAnnotation, typing.Dict[builtins.str, typing.Any]]],
    construct_path: builtins.str,
    dependencies: typing.Sequence[builtins.str],
    name: builtins.str,
    stack_metadata_path: builtins.str,
    synthesized_stack_path: builtins.str,
    working_directory: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0d4c7d99f672e21a621737a4672daae318d14054dd144e659b369de41b7acf9a(
    left: typing.Any,
    right: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f0258829598f3937eaacd1e76f1b51fec5354480a3d24474a5d3cd68ebdbdec2(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__41548a4bf795459ca25ffd9149a6377e9c63cd06407c7003b8ae18706acecbc2(
    _context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__dd959d179f1126c444986d044c2b0070e4884693df91a36be813f56468b2e992(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a40fdb0bc0fec4ac3ee3d0addd1cd8b085ff08c801d2c4d90eb9faf012d28ef5(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
    wraps_set: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__675c4da88a632d5e4e15b9071798ca88c1bfb01b32c21155bb26a8e36df84328(
    index: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__36d6002ff6898f1e07f76fd199122ef61feac20cf8ad4625475f3b04e2cd8177(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__efc36b987fc1253fc3e3709a91fc90c941b80c8e66b25cefb0aa861ea0354033(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fc5f547e6fb2026d4300a32e9845e7ce68edf0a679b7416e8de31fc9b57c226b(
    *,
    container: builtins.str,
    application_credential_id: typing.Optional[builtins.str] = None,
    application_credential_name: typing.Optional[builtins.str] = None,
    application_credential_secret: typing.Optional[builtins.str] = None,
    archive_container: typing.Optional[builtins.str] = None,
    auth_url: typing.Optional[builtins.str] = None,
    cacert_file: typing.Optional[builtins.str] = None,
    cert: typing.Optional[builtins.str] = None,
    cloud: typing.Optional[builtins.str] = None,
    default_domain: typing.Optional[builtins.str] = None,
    domain_id: typing.Optional[builtins.str] = None,
    domain_name: typing.Optional[builtins.str] = None,
    expire_after: typing.Optional[builtins.str] = None,
    insecure: typing.Optional[builtins.bool] = None,
    key: typing.Optional[builtins.str] = None,
    password: typing.Optional[builtins.str] = None,
    project_domain_id: typing.Optional[builtins.str] = None,
    project_domain_name: typing.Optional[builtins.str] = None,
    region_name: typing.Optional[builtins.str] = None,
    state_name: typing.Optional[builtins.str] = None,
    tenant_id: typing.Optional[builtins.str] = None,
    tenant_name: typing.Optional[builtins.str] = None,
    token: typing.Optional[builtins.str] = None,
    user_domain_id: typing.Optional[builtins.str] = None,
    user_domain_name: typing.Optional[builtins.str] = None,
    user_id: typing.Optional[builtins.str] = None,
    user_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a63ad742b06a1fc5c49fa8e353485748e0bed2af1637430e96dd29a98c24f9f7(
    tags: typing.Sequence[builtins.str],
    project: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__33141984c345982077d6f4e6b9dd8b925bafebea3ba27b44db4774fa5bdba72e(
    value: typing.List[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aa1d75ec4a2d0804ac24830d48635da71ca8dd59487a37a167f552a06e74225e(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6f29998a5dacee0da3977e8d51379662670eb6942990ac7e6e052ab5e3408d37(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    path: builtins.str,
    asset_hash: typing.Optional[builtins.str] = None,
    type: typing.Optional[AssetType] = None,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__03e61b89f49ef71fd8419a85339e3b4fbecbbadc295011656c2629a600c3d734(
    value: AssetType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e7a613b39a707470fb3fa76a5d5d750aa8285bec8b92786190d69d5b7f66db39(
    *,
    path: builtins.str,
    asset_hash: typing.Optional[builtins.str] = None,
    type: typing.Optional[AssetType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b336eac40603f44d46efd6bbf0d28b18b4f8355cc2e560877096240a812f968a(
    *,
    condition: typing.Any,
    error_message: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eeca2019246585cba23b2b3e8324a60dc582fb110dae06b370f63471b7e7f438(
    x: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9a8c063de56f4d554799a5d672e4ecc8be3bd1ed0542261b0ff8825bfe1fd74d(
    count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__fcd359885858fd4c036b7dd13adff5090336398ffc28d3b3f4c939535f39b33b(
    x: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5061998df7e324559c25dd72d32954de6d29a1dccc5e5c379864e487659bf85d(
    path: builtins.str,
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__fab9ced444c289534f0982bd872b70f1bcfed9fbdf3b06afeeff1085fa01aada(
    *,
    path: builtins.str,
    stack_trace: typing.Sequence[builtins.str],
    unique_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__06225d88c1d051bbf50c7b8a4b6efbad356c54a8d5a98d873eddc798401e5267(
    list: typing.Union[IResolvable, ComplexList, StringMapList, NumberMapList, BooleanMapList, AnyMapList],
    map_key_attribute_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ca407881f880f526ecdd3a655df6d825fc639b63e1ab866c3e8b2d48447fe872(
    resource: ITerraformResource,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4a3bd134e34b1f954589c409619eaeafb56545bc18372876271e5377410bd32d(
    list: typing.Union[typing.Sequence[builtins.str], IResolvable, typing.Sequence[jsii.Number], typing.Sequence[typing.Union[builtins.bool, IResolvable]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b5a1bc5fff8fe1a366a4355a93a2bf1b8624d6d39212e735ca891cc1859c94ee(
    map: typing.Union[ComplexMap, typing.Mapping[builtins.str, typing.Any], typing.Mapping[builtins.str, builtins.str], typing.Mapping[builtins.str, jsii.Number], typing.Mapping[builtins.str, builtins.bool]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d68664120105ffaeb47463bd04a63052d25e722da1abe9bfe4699b6e462f365e(
    resource: ITerraformResource,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f6ff49e0709ba3c7a5293c56a6a93c2bdc5d053661277717c36f8a6611722d95(
    attributes: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f2ee0c14aec737178e77676264491d3838151340d4b3e9ed7cafa29534f73884(
    expression: typing.Union[builtins.str, IResolvable],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a13efbc792c82bf1a2cfacfdc8c9f74699a8c3bfa9bd30bde11bd096a39cf582(
    key_expression: typing.Union[builtins.str, IResolvable],
    value_expression: typing.Union[builtins.str, IResolvable],
) -> None:
    """Type checking stubs"""
    pass

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

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

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

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

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

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

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

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

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

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

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

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

def _typecheckingstub__2d49f62fd3d83fad9b170b2f06bea7ae5127def3a7fc98fdbc0cbb181f9d7f0c(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    expression: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f0d11d1d44304e7881d94179c7891ba6064f89e001bfcb83cf61759cde052195(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b02860c1b4e814c6510c34c670b9b99b042f7be44fe49a1bd323776b951bbc99(
    *,
    connection: typing.Optional[typing.Union[typing.Union[SSHProvisionerConnection, typing.Dict[builtins.str, typing.Any]], typing.Union[WinrmProvisionerConnection, typing.Dict[builtins.str, typing.Any]]]] = None,
    count: typing.Optional[typing.Union[jsii.Number, TerraformCount]] = None,
    depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
    for_each: typing.Optional[ITerraformIterator] = None,
    lifecycle: typing.Optional[typing.Union[TerraformResourceLifecycle, typing.Dict[builtins.str, typing.Any]]] = None,
    provider: typing.Optional[TerraformProvider] = None,
    provisioners: typing.Optional[typing.Sequence[typing.Union[typing.Union[FileProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[LocalExecProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[RemoteExecProvisioner, typing.Dict[builtins.str, typing.Any]]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__453f55919a014c6d4e1928655313b12ae89cf53fcb1f7c930e6a341ba17a0701(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    source: builtins.str,
    version: typing.Optional[builtins.str] = None,
    depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
    for_each: typing.Optional[ITerraformIterator] = None,
    providers: typing.Optional[typing.Sequence[typing.Union[TerraformProvider, typing.Union[TerraformModuleProvider, typing.Dict[builtins.str, typing.Any]]]]] = None,
    skip_asset_creation_from_local_modules: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__12185f792feee97ba778dd08b9bd26dcddf88d78ec3e491fe6c18558242c041b(
    provider: typing.Union[TerraformProvider, typing.Union[TerraformModuleProvider, typing.Dict[builtins.str, typing.Any]]],
) -> None:
    """Type checking stubs"""
    pass

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

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

def _typecheckingstub__20e56226fee23b61f9cbada36fe7f3f784d137a5a44240bac904f7cff04970b5(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2c058963ccef1fd756c074cae46440ea9292f3b88600d0b8118795c451facd9d(
    value: typing.Optional[ITerraformIterator],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8304af0223196c2f94796cfb2497677c9e68924b90d193da74f07a304f1860c1(
    *,
    module_alias: builtins.str,
    provider: TerraformProvider,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a1aad1aec655a6400c69c9f245b7790ff2c2d7eed499fb5aa5c66082178e2ba1(
    *,
    depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
    for_each: typing.Optional[ITerraformIterator] = None,
    providers: typing.Optional[typing.Sequence[typing.Union[TerraformProvider, typing.Union[TerraformModuleProvider, typing.Dict[builtins.str, typing.Any]]]]] = None,
    skip_asset_creation_from_local_modules: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e2be71f636a5077e07a7c8520b67c6314531e050828228e087db0d1dbc07d878(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    value: typing.Any,
    depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
    description: typing.Optional[builtins.str] = None,
    precondition: typing.Optional[typing.Union[Precondition, typing.Dict[builtins.str, typing.Any]]] = None,
    sensitive: typing.Optional[builtins.bool] = None,
    static_id: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b171c7b35c78a7135ee8612adebc5f11dcb3fa834f6110e6dd5d32da04ad8107(
    x: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6b7bfcad8e947f6ca01ae1f36eb6e9f4400247d822ee40136e3c99167674cf13(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8ff3667f921b567ade83fd674a10381d40e3919a7562df90e2b6b615c2cea4e5(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d6c78adc9aadd2a9404b203d28ff9aee2dd3d59e6932409086d6308774bd9b88(
    value: typing.Optional[typing.List[ITerraformDependable]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aa3846fea41559cc28ca23bd1e6ddafe9dfd7b112b564eca0753dd240c0bf2ab(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__895ff9c2f7bb242c2ee0dd45d919efe8c00d32716f5ba1fc2f2e4121efa744e6(
    value: typing.Optional[Precondition],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1803c21388d9fa6d99a9b89f40235e5e446d414e5ff323ec7f82ab9f83faf42a(
    value: typing.Optional[builtins.bool],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aea7829b6c6337c700fffa9d1d1fb383b28e53c8d21cf1f575fba53b839d37e2(
    *,
    value: typing.Any,
    depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
    description: typing.Optional[builtins.str] = None,
    precondition: typing.Optional[typing.Union[Precondition, typing.Dict[builtins.str, typing.Any]]] = None,
    sensitive: typing.Optional[builtins.bool] = None,
    static_id: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f29ec5ee8fe90fcc2799b8475a18640147d6197734a045cbca786bd1022b1893(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    terraform_resource_type: builtins.str,
    terraform_generator_metadata: typing.Optional[typing.Union[TerraformProviderGeneratorMetadata, typing.Dict[builtins.str, typing.Any]]] = None,
    terraform_provider_source: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4fc04dea9e581a8742d8aec1907fc2d0de1a885c456083be46d4a774072f9b4a(
    x: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__456e906543548a5337cf60b23057ce623965903cebe176cd9056d7f26a7ff6df(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dd0ea1226e835522ba6118a50a3b6a2cc014e1d1ecace13f39dd2979e0e271b4(
    *,
    terraform_resource_type: builtins.str,
    terraform_generator_metadata: typing.Optional[typing.Union[TerraformProviderGeneratorMetadata, typing.Dict[builtins.str, typing.Any]]] = None,
    terraform_provider_source: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bcf3c96e47fcb9a54b8e7530163181b552b200de16ecc246811b468838978bda(
    *,
    provider_name: builtins.str,
    provider_version: typing.Optional[builtins.str] = None,
    provider_version_constraint: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1276fbe4187f97c166701a3d26700c3c7256ed52c628568aa721f9b2c3585bb9(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    backend: builtins.str,
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

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

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

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

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

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

def _typecheckingstub__d1ea2897bc4eed1005d89529a05c9509ef3e64dfa89ada96dfc7a64fecfd1351(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    terraform_resource_type: builtins.str,
    terraform_generator_metadata: typing.Optional[typing.Union[TerraformProviderGeneratorMetadata, typing.Dict[builtins.str, typing.Any]]] = None,
    connection: typing.Optional[typing.Union[typing.Union[SSHProvisionerConnection, typing.Dict[builtins.str, typing.Any]], typing.Union[WinrmProvisionerConnection, typing.Dict[builtins.str, typing.Any]]]] = None,
    count: typing.Optional[typing.Union[jsii.Number, TerraformCount]] = None,
    depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
    for_each: typing.Optional[ITerraformIterator] = None,
    lifecycle: typing.Optional[typing.Union[TerraformResourceLifecycle, typing.Dict[builtins.str, typing.Any]]] = None,
    provider: typing.Optional[TerraformProvider] = None,
    provisioners: typing.Optional[typing.Sequence[typing.Union[typing.Union[FileProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[LocalExecProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[RemoteExecProvisioner, typing.Dict[builtins.str, typing.Any]]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__215ab21290894e9bba753ea4baa29eb2592399af5b9bcb2d853052a953af82b2(
    x: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

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

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

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

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

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

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

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

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

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

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

def _typecheckingstub__d2f3e263f8c68f23cc9c5efc4581cf7cf544ba047f89df517b1543688e7b9ea3(
    id: builtins.str,
    provider: typing.Optional[TerraformProvider] = None,
) -> None:
    """Type checking stubs"""
    pass

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

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

def _typecheckingstub__ba688420b4b64efb0d932319bf4d5b192ee42ff73b4aa2dc6620dd8aeb31cbe5(
    move_target: builtins.str,
    index: typing.Optional[typing.Union[builtins.str, jsii.Number]] = None,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__435ff282656e4cf599f62153039ccd6c8d608af766877be8e47563123f57baa1(
    value: typing.Optional[typing.Union[SSHProvisionerConnection, WinrmProvisionerConnection]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bc1497fc0f2d401bb98674c41c6176895f98a0f2659b72d1f3538da0223e2d4b(
    value: typing.Optional[typing.Union[jsii.Number, TerraformCount]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7ab06c371f7bcbea1830dd4340375686c19fcb8b11532b60c52b97aefab9c679(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3b4c7e3415d903363aba287c646ee6141721e5466f5422d772f5cedaa815510e(
    value: typing.Optional[ITerraformIterator],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__44f9846bcf16b921c668f2a412e911da8493a63fb63b6ff727bcc3d306535a9b(
    value: typing.Optional[TerraformResourceLifecycle],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__da09c5c8a464d6ecefc038b43812a9beb24e745ce5e2e3ffb1c7db834757e65d(
    value: typing.Optional[TerraformProvider],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__97e0091145c8cb81cafc1be6eb746bd9872b36e2d9f2d7c6ed0286f7d281dd01(
    value: typing.Optional[typing.List[typing.Union[FileProvisioner, LocalExecProvisioner, RemoteExecProvisioner]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__45bbb555f892f64b72e5b78f4bfa51082b771111b6e05a0ecbacb18e24b2bb84(
    *,
    connection: typing.Optional[typing.Union[typing.Union[SSHProvisionerConnection, typing.Dict[builtins.str, typing.Any]], typing.Union[WinrmProvisionerConnection, typing.Dict[builtins.str, typing.Any]]]] = None,
    count: typing.Optional[typing.Union[jsii.Number, TerraformCount]] = None,
    depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
    for_each: typing.Optional[ITerraformIterator] = None,
    lifecycle: typing.Optional[typing.Union[TerraformResourceLifecycle, typing.Dict[builtins.str, typing.Any]]] = None,
    provider: typing.Optional[TerraformProvider] = None,
    provisioners: typing.Optional[typing.Sequence[typing.Union[typing.Union[FileProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[LocalExecProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[RemoteExecProvisioner, typing.Dict[builtins.str, typing.Any]]]]] = None,
    terraform_resource_type: builtins.str,
    terraform_generator_metadata: typing.Optional[typing.Union[TerraformProviderGeneratorMetadata, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__85e7052f901655028aa9095e8bd03e504ea17544341294c06021c0167be1f33d(
    *,
    id: builtins.str,
    provider: typing.Optional[TerraformProvider] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__407af3a931e3f84f33b666437dafcdf0ddc238de72b1b2b2a672009ed577428e(
    *,
    create_before_destroy: typing.Optional[builtins.bool] = None,
    ignore_changes: typing.Optional[typing.Union[typing.Sequence[builtins.str], builtins.str]] = None,
    postcondition: typing.Optional[typing.Sequence[typing.Union[Postcondition, typing.Dict[builtins.str, typing.Any]]]] = None,
    precondition: typing.Optional[typing.Sequence[typing.Union[Precondition, typing.Dict[builtins.str, typing.Any]]]] = None,
    prevent_destroy: typing.Optional[builtins.bool] = None,
    replace_triggered_by: typing.Optional[typing.Sequence[typing.Union[builtins.str, ITerraformDependable]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e6b8d99bc04769656865aa6976feb6c7059ae0425113fbbbb875de3a3c6efd9d(
    *,
    from_: builtins.str,
    to: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f8ead29bd3d21868f42eef51ed5bcfdb0c37ac7b55439f9fb9b77e46d6a6ea35(
    *,
    move_target: builtins.str,
    index: typing.Optional[typing.Union[builtins.str, jsii.Number]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a21400d80314ed3e958ef76e30a4efef48e7ad08ce4bf6288b9bd5a96e2bf17b(
    resource: TerraformResource,
    target: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

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

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

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

def _typecheckingstub__fe7cc9c0f474a20ab351b91bb1ff24294da15565cdbe837b0a39aedb3906d46d(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b3cc1266d71e18b813a55365caebc38c0e6313689418721ee237e1e149f23aea(
    x: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0f4ad6425136b110fcc986547778f2da43ba6a96b54ccd9618ded5433842ee25(
    construct: _constructs_77d1e7e8.IConstruct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7c596bcaca4f08b39ab9b69ad0bbf8713401da56876faa310aaee1786868e68e(
    dependency: TerraformStack,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__983a7759871db826f7849b3ec538ca23e46963f9d5f001c080a5c8a0f89dfa34(
    path: builtins.str,
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__81995ed9993d1687d068c687071f0a65f709bafa8be532e324bce983c6cd3aba(
    tf_element: typing.Union[_constructs_77d1e7e8.Node, TerraformElement],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__848536e95b42fb073abc5d703b9666de6e8d9f62ae006dc3ab9ff64e24c49c65(
    stack: TerraformStack,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ac63b7486cb2a705bf90134092b22480b1c01fd33ecc2582062574ccc0dd31fe(
    tf_element: typing.Union[_constructs_77d1e7e8.Node, TerraformElement],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f59d08fbe4359d82edaa4e1817aa13d68a8db6be88eebd9276ba69e7b9d38821(
    from_stack: TerraformStack,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__e6040423e55b90bfc10e20a794a96303d0333f383aed4eada61c48bc462434e1(
    value: typing.List[TerraformStack],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6fcf5e2a29bc4e9793f946f6b2e7c98a70363230e09c2cad0a7c652c011975fa(
    value: TerraformResourceTargets,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e1b3d9ed938408962e059234fbde4d2cd91f5a2105c00e3d3105e6a41d506776(
    value: IStackSynthesizer,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2c9b596787474264ad405763481e614acbecfbecd7882d4bb239efc0bb60c2f3(
    *,
    backend: builtins.str,
    stack_name: builtins.str,
    version: builtins.str,
    cloud: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a969035b8f865ea849733f7d75773ea4c66688586f214f1637b395adbf88c223(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    default: typing.Any = None,
    description: typing.Optional[builtins.str] = None,
    nullable: typing.Optional[builtins.bool] = None,
    sensitive: typing.Optional[builtins.bool] = None,
    type: typing.Optional[builtins.str] = None,
    validation: typing.Optional[typing.Sequence[typing.Union[TerraformVariableValidationConfig, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__41ac207b16d0a0a35cd187c0b2a67d73030a02ce461fe3819cc376ab138cbb6b(
    *,
    default: typing.Any = None,
    description: typing.Optional[builtins.str] = None,
    nullable: typing.Optional[builtins.bool] = None,
    sensitive: typing.Optional[builtins.bool] = None,
    type: typing.Optional[builtins.str] = None,
    validation: typing.Optional[typing.Sequence[typing.Union[TerraformVariableValidationConfig, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__69cc7e6136cc8e43a13e39d449a8bcda996c6ca783f3cf58b34000601a6540b8(
    *,
    condition: typing.Any,
    error_message: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d1763559f423b2c3bd4b7c7ed1e294651415a94e44e18c67a92f022d5818c51e(
    app: App,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__58c7cb862b7200385eb19ec8f21081639d9fe92275abcdbf088702f8943ad738(
    app: App,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b60a0582b77b2ac1167b99b2194a2d80a96166bde945c5d8a09111a65286009d(
    stack: TerraformStack,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9a5842df674b32b03f781ab4d610dabecb7da43fac9bed4fc37cf58a2d70b7c7(
    construct: _constructs_77d1e7e8.IConstruct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7d53a3670b7c5417376165f346ccd1ec40f4c623af4b83d37d5b6e2daa404f59(
    app: App,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__708be873e1eb9488e6cde21497ff9177ad18dac95d9a03d09a4386260c3bdd17(
    stack: TerraformStack,
    run_validations: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__459afd0ccca40a57a9946156a4069393ce0bafe18ad13b4a02644b34b0a21bf8(
    stack: TerraformStack,
    run_validations: typing.Optional[builtins.bool] = None,
    return_metadata: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__08f677a487438755df8d5551ce7c3ac4eeb764b3d10fe566244aa5c70df74fe3(
    fn: IScopeCallback,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__104f104124c8997f80ff16a066d01dba38faa7959b9ca8fcab72b8f44f7d7277(
    received: builtins.str,
    resource_type: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b89efe1c7a4317f3163281a3f15bb450efbe265aa8b65e9ef683f090af506a21(
    received: builtins.str,
    resource_type: builtins.str,
    properties: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__62b143487665be5357f9ffe8a2858c0f6288baa1c9872c9c0b8089d27b14e8d2(
    received: builtins.str,
    resource_type: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9b94c5f3242aa07baa0dfd8cd525104622027db6d0ad2248ca3a476c16f19bad(
    received: builtins.str,
    resource_type: builtins.str,
    properties: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__304edc769baf0e425a3207acd8cdc8481bfec595fb815a9cc1e2bcd59eae4f3e(
    received: builtins.str,
    resource_type: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eeed515a0a17633eac0cb32da5819e663ea932a4f2074089fbd70398dfc4e2fc(
    received: builtins.str,
    resource_type: builtins.str,
    properties: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__54ebed42df621f5e0f84c586a54b6bb7006a38bba2c37cdfd5cb22165b743e22(
    *,
    context: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    enable_future_flags: typing.Optional[builtins.bool] = None,
    fake_cdktf_json_path: typing.Optional[builtins.bool] = None,
    outdir: typing.Optional[builtins.str] = None,
    stack_traces: typing.Optional[builtins.bool] = None,
    stub_version: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fc2cd80016e9f94ac59b50e582e35b08dbf29bb09b05b08b2003fe479db11ce0(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d35a6be6d86454a16b83a0001bfe337c7fde1dbbc211a75d3466402e544aca2d(
    value: typing.Any,
    *,
    display_hint: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__55ed021c804ca095d1c1c528ace6a7f229d32f175807f73c4035d8fe16b4648d(
    value: typing.Any,
    *,
    display_hint: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6989bc34c30ed4684b7ee53f7819ad02efed73c93978358183d2ee51d7889906(
    value: typing.Any,
    *,
    display_hint: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ca2e0529b5c3ad3ed1d9caac6bfd77980cd0091a5a1d4b6fef86db6f419a956f(
    value: typing.Any,
    map_value: typing.Any,
    *,
    display_hint: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c4399f43bd8dded7c40f7ad23599b180813d8eb290159f01aa53f5100c5c8db4(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__335b6bfc8a5f027b594d82b93979ae32b68435b6ce301cab3695cb70cb81e69b(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c537112371292f9fcba99f73281f0c16ab952fa784453d4d7b9a7cb7ee6b3803(
    value: typing.Any,
    *,
    display_hint: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__42335670d8fc9bd10abb7ac0b2791311b96f5e719ebb23d93745f1415f45ef28(
    value: typing.Any,
    *,
    display_hint: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ec70f02947e6d29970d3cfe6c973938b6f7c30a6afac843edbe6875242568821(
    value: typing.Any,
    *,
    display_hint: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cede694fed113a58a15be36452d545bb2d5e400f448470fe12930a3309426c1f(
    obj: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2b1e3dd401bbec2c668fc76635fe5144d07edfe88c6f582e4003cf3c214f4167(
    obj: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b2e20c09b2c2c3be7b7941486816bd2168fe3cc67c66761ee9e115c8ba72b837(
    obj: typing.Any,
    *,
    resolver: ITokenResolver,
    scope: _constructs_77d1e7e8.IConstruct,
    preparing: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__36585866150c5a1486cd4a1a88557fd79f71301379b144933150fc14e7898c43(
    x: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8a90fcdf582806b8ddadfa6c0703cf9b79e6c11715546d4e90f0f41dfec0fadc(
    l: typing.Sequence[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__763100f1b78b113cb90c6679794ce40174f8466a3abe47320c5cba273f62c186(
    m: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__915bc6dffd808180690af80a1bfcc3d701f2659b4d386d6dfe3a87082bc581bb(
    n: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6a087f957e4b3b11006552646753964911a588b5df4cdc8ac52e0dfae9c01526(
    l: typing.Sequence[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__302830f1188af486903646901f86420db21828660a2fb8cc252422c599146208(
    x: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__cf1499b4dc541e9015aacaf427ff0826703cd9bd43e4c492bfec7685e406c695(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__11914f82a68bc3034468f060be634da21edccea26889ad9601127542cf13b343(
    lit: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c0558b50fadb857c241e3458711be70196edf14e603cd97450f5638583171176(
    token: IResolvable,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9a1302156b456acf39397723979f061e21ef955011da56edf3d52b8f1926f85e(
    other: TokenizedStringFragments,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e4560ceb1b64de42c523e63fb0b39ff1c5a80f45f5ddbc45fedfd7b443e6b758(
    concat: IFragmentConcatenator,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c6a2a9092fc7b0d69e682541e57008cf468ff527ec2b5afddeec67409d8056c6(
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

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

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

def _typecheckingstub__87149a89b8cf58365e8930eda5f43c2214b64439aa47fde55ba5373f61b7ad21(
    attributes: typing.Mapping[builtins.str, builtins.str],
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__5793ed0887c7db4221c0fa84e8326927e6094f2a5e821220c145a1ab020f2b3f(
    *elements: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4d651502c2fffe806b706fb54bd0004a60512941359af52ff80d63b3fa46da95(
    *,
    host: builtins.str,
    type: builtins.str,
    cacert: typing.Optional[builtins.str] = None,
    https: typing.Optional[builtins.bool] = None,
    insecure: typing.Optional[builtins.bool] = None,
    password: typing.Optional[builtins.str] = None,
    port: typing.Optional[jsii.Number] = None,
    script_path: typing.Optional[builtins.str] = None,
    timeout: typing.Optional[builtins.str] = None,
    use_ntlm: typing.Optional[builtins.bool] = None,
    user: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a22a11a22b1ca157a5e277d352bf3a37e3afaa03bdea4d45bc7997029918d5e6(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__08848319e8db762e31185da6ebbd74ff1f975827c2bbff040e382a7a87b20328(
    _context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__736d91502b2ab5ae4326febb1b5e1525ac8675c6729028f8933c719abc8817cd(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__32481cc58e63d8fc4832c4de265e5e382fbc84a2510799c6dc39925f21dab224(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
    wraps_set: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e1b8830c59e83f9e994768458e11d29807357cc2aba44cb8c2351a44687a4d82(
    index: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__d4a0dc743d561af4b57dfaa20280fe50ffcec0ecd4eb66809aa9b65a31f18abb(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5e1f247f17760d242529b193426d35393d32b13993491b17a8d42c996cce8613(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b4cbbedf36a8746a1d5c9c145d7b08835c4ba037baf7c170a739d514ac054c5d(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__1ffc6974ca39c18d416f399dc0c56338b30103327c8e470612bcf3d374ec3a0a(
    _context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__187c7e3ac23a4127cda72763b630138a12a9e394e7b020118573e29c40bca0ff(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b612a5135fee22a20c547b9844f3ae29a2123eb6d1ba91abb7142c9ec4b74ab3(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
    wraps_set: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__096c48672b3a18aa12a074402f5f733fc4adc30de603ee69fe68825fb8df9b98(
    index: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__a53cff012c477cff4b94cf595d52ea50e16f306c3c607472e124f005241bf080(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ae11341a79bbd420fb007854cf069fe6d43cee030165e31290d50f14d6ac3eea(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__383f75d3115cefe50368b79b9cef65b6997c768310bb192c74f470cf288d8b78(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
    complex_computed_list_index: builtins.str,
    wraps_set: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

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

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

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

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

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

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

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

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

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

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

def _typecheckingstub__8d21ac623c8f127f8545bbecebd93d169af32649a0cb5a291919fcad4b01e6a9(
    _context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

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

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

def _typecheckingstub__108c7f34d26f4752b0921ec0e278a4fc128f7defee7aeacd687475413ec74fa2(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__38e4119708c882053c9fe3e3f097b88506a6097f11b2ad2563c78c9d6409f9b9(
    value: typing.Optional[builtins.bool],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6be83ebe8558373d4bc8f4722aa69e58cae8a0946b2efb60ecbcd31c687e3671(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
    wraps_set: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__5d10780f0e7d635e94a953cca7fd0edaf91b68167e6c6cabae5f02639ce44172(
    _context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__b93c5fde9deea93927dfda55a14707434f25cc66a12659395724b4c19c47ef07(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4b99eaea79cb6ebec1931745b4c0b0638594b204cf7af324c07dbec4e5c2106f(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c854ee500d97a0dbe62b21bcb07bbcc889a77bfba058310e8b73f83435b6f745(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__fdd82e635edaf6d01515e7543eea9eef72b33dc9aa75f1cc543dd7e92e711545(
    _context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__4c21d5227b4f9b4595ce774d47fd776fd8d768233298e1f612b2220e2b7e5280(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__554b2fd9c18fe556ec0149ca5fa50e75fcbaec92b20820287b32e11980c21ecc(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
    complex_object_is_from_set: builtins.bool,
    complex_object_index: typing.Optional[typing.Union[builtins.str, jsii.Number]] = None,
) -> None:
    """Type checking stubs"""
    pass

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

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

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

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

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

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

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

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

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

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

def _typecheckingstub__292bb76f19e1a948c73ec009167906adec42237d61c77331fbddb681cde27be1(
    _context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ba84737b1aaf2246be224622a461d7613d90fb85cf98ba3d77175c30d46db121(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__55ac77e0ff614052ca7f96a7236bd5d019ab07fa92db574958fa75cdaa7c147b(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__07d6bb88b4f1626c232244085ff9d963adfe5257bbc190fe6081e9f5cb4adfc1(
    value: typing.Optional[typing.Union[builtins.str, jsii.Number]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__057c7d96213cc8ce7538cd2287db4e8fa4adaddbe87adb7a12ea3dd9a02bdcbb(
    *,
    connection: typing.Optional[typing.Union[typing.Union[SSHProvisionerConnection, typing.Dict[builtins.str, typing.Any]], typing.Union[WinrmProvisionerConnection, typing.Dict[builtins.str, typing.Any]]]] = None,
    count: typing.Optional[typing.Union[jsii.Number, TerraformCount]] = None,
    depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
    for_each: typing.Optional[ITerraformIterator] = None,
    lifecycle: typing.Optional[typing.Union[TerraformResourceLifecycle, typing.Dict[builtins.str, typing.Any]]] = None,
    provider: typing.Optional[TerraformProvider] = None,
    provisioners: typing.Optional[typing.Sequence[typing.Union[typing.Union[FileProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[LocalExecProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[RemoteExecProvisioner, typing.Dict[builtins.str, typing.Any]]]]] = None,
    input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    triggers_replace: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__53ee2b83542d7e9f32ef416d97e9f6cd35cfafe3e01a6da0cf938ea287c399d5(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    input: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    triggers_replace: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    connection: typing.Optional[typing.Union[typing.Union[SSHProvisionerConnection, typing.Dict[builtins.str, typing.Any]], typing.Union[WinrmProvisionerConnection, typing.Dict[builtins.str, typing.Any]]]] = None,
    count: typing.Optional[typing.Union[jsii.Number, TerraformCount]] = None,
    depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
    for_each: typing.Optional[ITerraformIterator] = None,
    lifecycle: typing.Optional[typing.Union[TerraformResourceLifecycle, typing.Dict[builtins.str, typing.Any]]] = None,
    provider: typing.Optional[TerraformProvider] = None,
    provisioners: typing.Optional[typing.Sequence[typing.Union[typing.Union[FileProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[LocalExecProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[RemoteExecProvisioner, typing.Dict[builtins.str, typing.Any]]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dba84ace82fde4eaf7e4c14b3080ce0b866a28f83d1f27af60cc2583f6dc9e37(
    scope: _constructs_77d1e7e8.Construct,
    import_to_id: builtins.str,
    import_from_id: builtins.str,
    provider: typing.Optional[TerraformProvider] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5d16227f257dbd5d33c5e910ea4d33e209766fb155a3a21622e834a579eb002b(
    value: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1a15568f1d7619b5b53e1d0d7039e1949214f9049bc31935adab5c586f774eba(
    value: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__863f037dc57c8bbc6ef45a85f5789f9a5b59652a9af40192ebcebbe49aa2fc75(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    organization: builtins.str,
    workspaces: IRemoteWorkspace,
    hostname: typing.Optional[builtins.str] = None,
    token: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d36f36687c8298603d4abc2d50db09a4d3fa5fc329fd72fe8b79da898af21010(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    container_name: builtins.str,
    key: builtins.str,
    storage_account_name: builtins.str,
    access_key: typing.Optional[builtins.str] = None,
    client_certificate_password: typing.Optional[builtins.str] = None,
    client_certificate_path: typing.Optional[builtins.str] = None,
    client_id: typing.Optional[builtins.str] = None,
    client_secret: typing.Optional[builtins.str] = None,
    endpoint: typing.Optional[builtins.str] = None,
    environment: typing.Optional[builtins.str] = None,
    metadata_host: typing.Optional[builtins.str] = None,
    msi_endpoint: typing.Optional[builtins.str] = None,
    oidc_request_token: typing.Optional[builtins.str] = None,
    oidc_request_url: typing.Optional[builtins.str] = None,
    oidc_token: typing.Optional[builtins.str] = None,
    oidc_token_file_path: typing.Optional[builtins.str] = None,
    resource_group_name: typing.Optional[builtins.str] = None,
    sas_token: typing.Optional[builtins.str] = None,
    snapshot: typing.Optional[builtins.bool] = None,
    subscription_id: typing.Optional[builtins.str] = None,
    tenant_id: typing.Optional[builtins.str] = None,
    use_azuread_auth: typing.Optional[builtins.bool] = None,
    use_microsoft_graph: typing.Optional[builtins.bool] = None,
    use_msi: typing.Optional[builtins.bool] = None,
    use_oidc: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__da44dc0bd9c6e94fe3ca5295fddc0180a8970650564e1c8f0a45037648494ddd(
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    container_name: builtins.str,
    key: builtins.str,
    storage_account_name: builtins.str,
    access_key: typing.Optional[builtins.str] = None,
    client_certificate_password: typing.Optional[builtins.str] = None,
    client_certificate_path: typing.Optional[builtins.str] = None,
    client_id: typing.Optional[builtins.str] = None,
    client_secret: typing.Optional[builtins.str] = None,
    endpoint: typing.Optional[builtins.str] = None,
    environment: typing.Optional[builtins.str] = None,
    metadata_host: typing.Optional[builtins.str] = None,
    msi_endpoint: typing.Optional[builtins.str] = None,
    oidc_request_token: typing.Optional[builtins.str] = None,
    oidc_request_url: typing.Optional[builtins.str] = None,
    oidc_token: typing.Optional[builtins.str] = None,
    oidc_token_file_path: typing.Optional[builtins.str] = None,
    resource_group_name: typing.Optional[builtins.str] = None,
    sas_token: typing.Optional[builtins.str] = None,
    snapshot: typing.Optional[builtins.bool] = None,
    subscription_id: typing.Optional[builtins.str] = None,
    tenant_id: typing.Optional[builtins.str] = None,
    use_azuread_auth: typing.Optional[builtins.bool] = None,
    use_microsoft_graph: typing.Optional[builtins.bool] = None,
    use_msi: typing.Optional[builtins.bool] = None,
    use_oidc: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4a2919d5d4b353733457cac7a6ec307201582ddaeed3b88b6ee25afb843eab7d(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    access_token: builtins.str,
    path: builtins.str,
    address: typing.Optional[builtins.str] = None,
    ca_file: typing.Optional[builtins.str] = None,
    cert_file: typing.Optional[builtins.str] = None,
    datacenter: typing.Optional[builtins.str] = None,
    gzip: typing.Optional[builtins.bool] = None,
    http_auth: typing.Optional[builtins.str] = None,
    key_file: typing.Optional[builtins.str] = None,
    lock: typing.Optional[builtins.bool] = None,
    scheme: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7befd4a3968d2c3bb3c5266e7c42ef8867bde80a6a366f391926498bac179949(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    bucket: builtins.str,
    accelerate: typing.Optional[builtins.bool] = None,
    acl: typing.Optional[builtins.str] = None,
    assume_role: typing.Optional[typing.Union[CosBackendAssumeRole, typing.Dict[builtins.str, typing.Any]]] = None,
    domain: typing.Optional[builtins.str] = None,
    encrypt: typing.Optional[builtins.bool] = None,
    endpoint: typing.Optional[builtins.str] = None,
    key: typing.Optional[builtins.str] = None,
    prefix: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    secret_id: typing.Optional[builtins.str] = None,
    secret_key: typing.Optional[builtins.str] = None,
    security_token: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__54b71c4e429ad3f144735cc6763f6c752653379ab351d875822950c26d2fefb6(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    bucket: builtins.str,
    access_token: typing.Optional[builtins.str] = None,
    credentials: typing.Optional[builtins.str] = None,
    encryption_key: typing.Optional[builtins.str] = None,
    impersonate_service_account: typing.Optional[builtins.str] = None,
    impersonate_service_account_delegates: typing.Optional[typing.Sequence[builtins.str]] = None,
    kms_encryption_key: typing.Optional[builtins.str] = None,
    prefix: typing.Optional[builtins.str] = None,
    storeage_custom_endpoint: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c69baeac37f85edb137a8d5ca2999cf1c01bf6e2a63b14cf60194706808b22e6(
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    bucket: builtins.str,
    access_token: typing.Optional[builtins.str] = None,
    credentials: typing.Optional[builtins.str] = None,
    encryption_key: typing.Optional[builtins.str] = None,
    impersonate_service_account: typing.Optional[builtins.str] = None,
    impersonate_service_account_delegates: typing.Optional[typing.Sequence[builtins.str]] = None,
    kms_encryption_key: typing.Optional[builtins.str] = None,
    prefix: typing.Optional[builtins.str] = None,
    storeage_custom_endpoint: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0cdf7aff3870beec242c5a780b67285fd9f81a5d44b2663f9b0e2dc8997783f3(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    address: builtins.str,
    client_ca_certificate_pem: typing.Optional[builtins.str] = None,
    client_certificate_pem: typing.Optional[builtins.str] = None,
    client_private_key_pem: typing.Optional[builtins.str] = None,
    lock_address: typing.Optional[builtins.str] = None,
    lock_method: typing.Optional[builtins.str] = None,
    password: typing.Optional[builtins.str] = None,
    retry_max: typing.Optional[jsii.Number] = None,
    retry_wait_max: typing.Optional[jsii.Number] = None,
    retry_wait_min: typing.Optional[jsii.Number] = None,
    skip_cert_verification: typing.Optional[builtins.bool] = None,
    unlock_address: typing.Optional[builtins.str] = None,
    unlock_method: typing.Optional[builtins.str] = None,
    update_method: typing.Optional[builtins.str] = None,
    username: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__82bd6e4bba7cf98508287662a5c3690d1f4fcb8805ba713fbd5e13d580af9f8c(
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    address: builtins.str,
    client_ca_certificate_pem: typing.Optional[builtins.str] = None,
    client_certificate_pem: typing.Optional[builtins.str] = None,
    client_private_key_pem: typing.Optional[builtins.str] = None,
    lock_address: typing.Optional[builtins.str] = None,
    lock_method: typing.Optional[builtins.str] = None,
    password: typing.Optional[builtins.str] = None,
    retry_max: typing.Optional[jsii.Number] = None,
    retry_wait_max: typing.Optional[jsii.Number] = None,
    retry_wait_min: typing.Optional[jsii.Number] = None,
    skip_cert_verification: typing.Optional[builtins.bool] = None,
    unlock_address: typing.Optional[builtins.str] = None,
    unlock_method: typing.Optional[builtins.str] = None,
    update_method: typing.Optional[builtins.str] = None,
    username: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c572f8e57424eb4b543f2fcf02998c3a0e6d767d6e97a8db79bfb56e52541a18(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    path: typing.Optional[builtins.str] = None,
    workspace_dir: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__41e7d0b4f0f6e336b16949d937e4e976edffbc253c263d4824fb6a0db3fcfa35(
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    path: typing.Optional[builtins.str] = None,
    workspace_dir: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5e0bc032b75ac727fb74f1a9e202198ca7f13c07a6ca91f779cebe83a9a43ee1(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    bucket: builtins.str,
    access_key: typing.Optional[builtins.str] = None,
    acl: typing.Optional[builtins.str] = None,
    assume_role: typing.Optional[typing.Union[OssAssumeRole, typing.Dict[builtins.str, typing.Any]]] = None,
    assume_role_policy: typing.Optional[builtins.str] = None,
    assume_role_role_arn: typing.Optional[builtins.str] = None,
    assume_role_session_expiration: typing.Optional[jsii.Number] = None,
    assume_role_session_name: typing.Optional[builtins.str] = None,
    ecs_role_name: typing.Optional[builtins.str] = None,
    encrypt: typing.Optional[builtins.bool] = None,
    endpoint: typing.Optional[builtins.str] = None,
    key: typing.Optional[builtins.str] = None,
    prefix: typing.Optional[builtins.str] = None,
    profile: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    secret_key: typing.Optional[builtins.str] = None,
    security_token: typing.Optional[builtins.str] = None,
    shared_credentials_file: typing.Optional[builtins.str] = None,
    sts_endpoint: typing.Optional[builtins.str] = None,
    tablestore_endpoint: typing.Optional[builtins.str] = None,
    tablestore_table: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e9ffb7d920480b404e1906d0f3f146a90dc8f5a0d08d2f47e4daa1723eb2e6ef(
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    bucket: builtins.str,
    access_key: typing.Optional[builtins.str] = None,
    acl: typing.Optional[builtins.str] = None,
    assume_role: typing.Optional[typing.Union[OssAssumeRole, typing.Dict[builtins.str, typing.Any]]] = None,
    assume_role_policy: typing.Optional[builtins.str] = None,
    assume_role_role_arn: typing.Optional[builtins.str] = None,
    assume_role_session_expiration: typing.Optional[jsii.Number] = None,
    assume_role_session_name: typing.Optional[builtins.str] = None,
    ecs_role_name: typing.Optional[builtins.str] = None,
    encrypt: typing.Optional[builtins.bool] = None,
    endpoint: typing.Optional[builtins.str] = None,
    key: typing.Optional[builtins.str] = None,
    prefix: typing.Optional[builtins.str] = None,
    profile: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    secret_key: typing.Optional[builtins.str] = None,
    security_token: typing.Optional[builtins.str] = None,
    shared_credentials_file: typing.Optional[builtins.str] = None,
    sts_endpoint: typing.Optional[builtins.str] = None,
    tablestore_endpoint: typing.Optional[builtins.str] = None,
    tablestore_table: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a03e4edfed23b03162d1ff8b05944a64b3c8755f4397d4994cfdd8f3828e8787(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    conn_str: builtins.str,
    schema_name: typing.Optional[builtins.str] = None,
    skip_index_creation: typing.Optional[builtins.bool] = None,
    skip_schema_creation: typing.Optional[builtins.bool] = None,
    skip_table_creation: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__576a0e230ad4aaa9d88be8e4e8b10641aaf3e690f7ea44d6feda09df386f4256(
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    conn_str: builtins.str,
    schema_name: typing.Optional[builtins.str] = None,
    skip_index_creation: typing.Optional[builtins.bool] = None,
    skip_schema_creation: typing.Optional[builtins.bool] = None,
    skip_table_creation: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9d4dd626119f3592cae0f08752c34d8cb02cc416fba3e72bf476fdb3d69040fc(
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    organization: builtins.str,
    workspaces: IRemoteWorkspace,
    hostname: typing.Optional[builtins.str] = None,
    token: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e2e03d6f3d69e37add63c033321c1e0024b24fd2b0cc457cea463794befdbb7b(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    bucket: builtins.str,
    key: builtins.str,
    access_key: typing.Optional[builtins.str] = None,
    acl: typing.Optional[builtins.str] = None,
    allowed_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    assume_role: typing.Optional[typing.Union[S3BackendAssumeRoleConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    assume_role_policy: typing.Optional[builtins.str] = None,
    assume_role_policy_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
    assume_role_tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    assume_role_transitive_tag_keys: typing.Optional[typing.Sequence[builtins.str]] = None,
    assume_role_with_web_identity: typing.Optional[typing.Union[S3BackendAssumeRoleWithWebIdentityConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    custom_ca_bundle: typing.Optional[builtins.str] = None,
    dynamodb_endpoint: typing.Optional[builtins.str] = None,
    dynamodb_table: typing.Optional[builtins.str] = None,
    ec2_metadata_service_endpoint: typing.Optional[builtins.str] = None,
    ec2_metadata_service_endpoint_mode: typing.Optional[builtins.str] = None,
    encrypt: typing.Optional[builtins.bool] = None,
    endpoint: typing.Optional[builtins.str] = None,
    endpoints: typing.Optional[typing.Union[S3BackendEndpointConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    external_id: typing.Optional[builtins.str] = None,
    forbidden_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    force_path_style: typing.Optional[builtins.bool] = None,
    http_proxy: typing.Optional[builtins.str] = None,
    https_proxy: typing.Optional[builtins.str] = None,
    iam_endpoint: typing.Optional[builtins.str] = None,
    insecure: typing.Optional[builtins.bool] = None,
    kms_key_id: typing.Optional[builtins.str] = None,
    max_retries: typing.Optional[jsii.Number] = None,
    no_proxy: typing.Optional[builtins.str] = None,
    profile: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    retry_mode: typing.Optional[builtins.str] = None,
    role_arn: typing.Optional[builtins.str] = None,
    secret_key: typing.Optional[builtins.str] = None,
    session_name: typing.Optional[builtins.str] = None,
    shared_config_files: typing.Optional[typing.Sequence[builtins.str]] = None,
    shared_credentials_file: typing.Optional[builtins.str] = None,
    shared_credentials_files: typing.Optional[typing.Sequence[builtins.str]] = None,
    skip_credentials_validation: typing.Optional[builtins.bool] = None,
    skip_metadata_api_check: typing.Optional[builtins.bool] = None,
    skip_region_validation: typing.Optional[builtins.bool] = None,
    skip_requesting_account_id: typing.Optional[builtins.bool] = None,
    skip_s3_checksum: typing.Optional[builtins.bool] = None,
    sse_customer_key: typing.Optional[builtins.str] = None,
    sts_endpoint: typing.Optional[builtins.str] = None,
    sts_region: typing.Optional[builtins.str] = None,
    token: typing.Optional[builtins.str] = None,
    use_legacy_workflow: typing.Optional[builtins.bool] = None,
    use_path_style: typing.Optional[builtins.bool] = None,
    workspace_key_prefix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__854b50f50b4391053c1124f2240fe5425fe0f99b959021463c404f1fff738dc4(
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    bucket: builtins.str,
    key: builtins.str,
    access_key: typing.Optional[builtins.str] = None,
    acl: typing.Optional[builtins.str] = None,
    allowed_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    assume_role: typing.Optional[typing.Union[S3BackendAssumeRoleConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    assume_role_policy: typing.Optional[builtins.str] = None,
    assume_role_policy_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
    assume_role_tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    assume_role_transitive_tag_keys: typing.Optional[typing.Sequence[builtins.str]] = None,
    assume_role_with_web_identity: typing.Optional[typing.Union[S3BackendAssumeRoleWithWebIdentityConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    custom_ca_bundle: typing.Optional[builtins.str] = None,
    dynamodb_endpoint: typing.Optional[builtins.str] = None,
    dynamodb_table: typing.Optional[builtins.str] = None,
    ec2_metadata_service_endpoint: typing.Optional[builtins.str] = None,
    ec2_metadata_service_endpoint_mode: typing.Optional[builtins.str] = None,
    encrypt: typing.Optional[builtins.bool] = None,
    endpoint: typing.Optional[builtins.str] = None,
    endpoints: typing.Optional[typing.Union[S3BackendEndpointConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    external_id: typing.Optional[builtins.str] = None,
    forbidden_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    force_path_style: typing.Optional[builtins.bool] = None,
    http_proxy: typing.Optional[builtins.str] = None,
    https_proxy: typing.Optional[builtins.str] = None,
    iam_endpoint: typing.Optional[builtins.str] = None,
    insecure: typing.Optional[builtins.bool] = None,
    kms_key_id: typing.Optional[builtins.str] = None,
    max_retries: typing.Optional[jsii.Number] = None,
    no_proxy: typing.Optional[builtins.str] = None,
    profile: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    retry_mode: typing.Optional[builtins.str] = None,
    role_arn: typing.Optional[builtins.str] = None,
    secret_key: typing.Optional[builtins.str] = None,
    session_name: typing.Optional[builtins.str] = None,
    shared_config_files: typing.Optional[typing.Sequence[builtins.str]] = None,
    shared_credentials_file: typing.Optional[builtins.str] = None,
    shared_credentials_files: typing.Optional[typing.Sequence[builtins.str]] = None,
    skip_credentials_validation: typing.Optional[builtins.bool] = None,
    skip_metadata_api_check: typing.Optional[builtins.bool] = None,
    skip_region_validation: typing.Optional[builtins.bool] = None,
    skip_requesting_account_id: typing.Optional[builtins.bool] = None,
    skip_s3_checksum: typing.Optional[builtins.bool] = None,
    sse_customer_key: typing.Optional[builtins.str] = None,
    sts_endpoint: typing.Optional[builtins.str] = None,
    sts_region: typing.Optional[builtins.str] = None,
    token: typing.Optional[builtins.str] = None,
    use_legacy_workflow: typing.Optional[builtins.bool] = None,
    use_path_style: typing.Optional[builtins.bool] = None,
    workspace_key_prefix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a7b949ef22206fbefe3532cbf8f6d07008c651dded9112233bc0fa83d9b485e6(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    container: builtins.str,
    application_credential_id: typing.Optional[builtins.str] = None,
    application_credential_name: typing.Optional[builtins.str] = None,
    application_credential_secret: typing.Optional[builtins.str] = None,
    archive_container: typing.Optional[builtins.str] = None,
    auth_url: typing.Optional[builtins.str] = None,
    cacert_file: typing.Optional[builtins.str] = None,
    cert: typing.Optional[builtins.str] = None,
    cloud: typing.Optional[builtins.str] = None,
    default_domain: typing.Optional[builtins.str] = None,
    domain_id: typing.Optional[builtins.str] = None,
    domain_name: typing.Optional[builtins.str] = None,
    expire_after: typing.Optional[builtins.str] = None,
    insecure: typing.Optional[builtins.bool] = None,
    key: typing.Optional[builtins.str] = None,
    password: typing.Optional[builtins.str] = None,
    project_domain_id: typing.Optional[builtins.str] = None,
    project_domain_name: typing.Optional[builtins.str] = None,
    region_name: typing.Optional[builtins.str] = None,
    state_name: typing.Optional[builtins.str] = None,
    tenant_id: typing.Optional[builtins.str] = None,
    tenant_name: typing.Optional[builtins.str] = None,
    token: typing.Optional[builtins.str] = None,
    user_domain_id: typing.Optional[builtins.str] = None,
    user_domain_name: typing.Optional[builtins.str] = None,
    user_id: typing.Optional[builtins.str] = None,
    user_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a21fb45814156b194363fd70ca255c3d57c3e2547dfe878e8b876d2c74e898da(
    *,
    defaults: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    workspace: typing.Optional[builtins.str] = None,
    container: builtins.str,
    application_credential_id: typing.Optional[builtins.str] = None,
    application_credential_name: typing.Optional[builtins.str] = None,
    application_credential_secret: typing.Optional[builtins.str] = None,
    archive_container: typing.Optional[builtins.str] = None,
    auth_url: typing.Optional[builtins.str] = None,
    cacert_file: typing.Optional[builtins.str] = None,
    cert: typing.Optional[builtins.str] = None,
    cloud: typing.Optional[builtins.str] = None,
    default_domain: typing.Optional[builtins.str] = None,
    domain_id: typing.Optional[builtins.str] = None,
    domain_name: typing.Optional[builtins.str] = None,
    expire_after: typing.Optional[builtins.str] = None,
    insecure: typing.Optional[builtins.bool] = None,
    key: typing.Optional[builtins.str] = None,
    password: typing.Optional[builtins.str] = None,
    project_domain_id: typing.Optional[builtins.str] = None,
    project_domain_name: typing.Optional[builtins.str] = None,
    region_name: typing.Optional[builtins.str] = None,
    state_name: typing.Optional[builtins.str] = None,
    tenant_id: typing.Optional[builtins.str] = None,
    tenant_name: typing.Optional[builtins.str] = None,
    token: typing.Optional[builtins.str] = None,
    user_domain_id: typing.Optional[builtins.str] = None,
    user_domain_name: typing.Optional[builtins.str] = None,
    user_id: typing.Optional[builtins.str] = None,
    user_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f2b95f794823341f37ee593434355a464d52dc6e73138e44c124fd1a153141b2(
    concat: IFragmentConcatenator,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6056680db093e603c1b0e3932d2764af0a50af14c58a9ee2660c2287b5a5409f(
    xs: typing.Sequence[builtins.str],
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0a174184a30b505b73373dc6bdcb0b205a58fff873589cb4ff366f1200721203(
    xs: typing.Mapping[builtins.str, typing.Any],
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bb4c86d87df095d23f4cae1d883d72bbd2609121f17dd640369d4c182f0233e0(
    xs: typing.Sequence[jsii.Number],
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__293ff48c71fb097f1077397301da72b8d62680dbed80a3af6896154e66ae21e1(
    fragments: TokenizedStringFragments,
    context: IResolveContext,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__641a39ca952ea8de54da6a148deeb5cbaf15fed101307489a3338212680f2c62(
    t: IResolvable,
    context: IResolveContext,
    post_processor: IPostProcessor,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4c5467c68090942094aed743904a13e7fc8aec87220ee78eb0be1fec7c953667(
    str: builtins.str,
    cost: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f594512f4c16c4f129b6798263de835601f32e7474def17a7a41dbe01bb86739(
    condition: typing.Any,
    true_value: typing.Any,
    false_value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3b9575296fdfdf297bf540cd6c330e358acd3c2746d1361e49a88b7404b6c33f(
    separator: builtins.str,
    list: typing.Sequence[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d3828023e169a0e571da531e01584927c3552aebae8dc798916eab203d877fc5(
    input_map: typing.Any,
    key: builtins.str,
    default_value: typing.Any = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4ed2533a68e0c9207319a96c375f8d7b50d5b776ff4617706a5a44e80322b244(
    input_map: typing.Any,
    path: typing.Sequence[typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bc7a76fbacde6913f9a72019b61a4c1a13eaff40f9a294ea7bdceb45ef865d52(
    start: jsii.Number,
    limit: jsii.Number,
    step: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__3a864fc54f2ce1cec2cac2d50edf70b1efc0d97c5d4361ce4ade3531f0e6bd1b(
    scope: _constructs_77d1e7e8.Construct,
    name: builtins.str,
    config: IImportableConfig,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bff9577b80efe93cd92790ad069033a88b86c00ba3e3c61f1c9d94dc2c180114(
    list: typing.Union[typing.Sequence[builtins.str], IResolvable, typing.Sequence[jsii.Number], typing.Sequence[typing.Union[builtins.bool, IResolvable]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ce20ad81cfc28b15ef4f724cb63097e918f91423285c83d986a3f4b36c716567(
    map: typing.Union[AnyMap, StringMap, NumberMap, BooleanMap, ComplexMap, typing.Mapping[builtins.str, typing.Any], typing.Mapping[builtins.str, builtins.str], typing.Mapping[builtins.str, jsii.Number]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__377e1e40d4a4fed37cb40fd6c5e353a99401c62c637d0b507bbdc6ad75ba8c1b(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
    wraps_set: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__587933ef9ec3abf46e938de00d234a7e733434ed884b519c4344be128489102a(
    index: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__29d505b0c1d642210eee22317dfbf8e0585ac9e68fc5462ebebb78b9305ef174(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4602c433f12bb554b396c6abd6c505833ef3a9e9cd23d2728c2b92a87230be44(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3dfcebae9c364365fcc06a8c4600122becd1dac9da575e3787caaf385b60f00f(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

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

def _typecheckingstub__2226bdf009964e1e76d0abd38167c0b3b45fc6d84c6cf0000b799d467b3d49e3(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e711777cba24fbe9d48a70e7c4344d7b32b0f81a58f544e556de4a4ebee968be(
    *,
    condition: typing.Any,
    error_message: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__611700f74474891eb1702fbbf4894fd2f0577b14f763d6b28a068023d836979a(
    *,
    condition: typing.Any,
    error_message: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d856fa24b334264240bb244284b70a4b13dbefb2734f92650a3c9f0fe05adfc4(
    element: ITerraformResource,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ae639d57097f43a3aa82fd8387b52e259b8e5469a6ab1815c83b9842a34d65f2(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
    wraps_set: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__83ed1169b003bcfcd74fd0466801bbdb1b39de5a53b1b6294fbfdc143bbbe83d(
    index: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__bf26a6f7b34e9a17032a5106604e633317996d42186dbcb1edd82c6074f1e70b(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e0743f08909faee723dd22da5a98fd5ad349f81069ff8673d6e661c8422cd685(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fbd1f72f72ea827f8a1bbb28d195f94def6676fb5338faf323f59651be1ec6f2(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

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

def _typecheckingstub__d77b6e7699a39ba03848e76ac4a00208ab5e8c8bc1ba7dc9dfc4b947482945f1(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9879ecc912d8d803dd95efd3bcbd6377f8ba3395f5a3e76fb06594c51f2a3385(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__76aae6fdf466efc66fd849a25cd46a145beee041c98fbc2b41220a3fcbd9d092(
    x: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b69861f032db45a9e14cf4f04bc733facf9e92cdafbe666c9737ea2fae5a3acf(
    scope: _constructs_77d1e7e8.Construct,
    name: builtins.str,
    from_stack: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__79e70c02e316a3d97b837eb6fc8e7fe114471049fcb998f605f6bbd388988a79(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    terraform_resource_type: builtins.str,
    terraform_generator_metadata: typing.Optional[typing.Union[TerraformProviderGeneratorMetadata, typing.Dict[builtins.str, typing.Any]]] = None,
    connection: typing.Optional[typing.Union[typing.Union[SSHProvisionerConnection, typing.Dict[builtins.str, typing.Any]], typing.Union[WinrmProvisionerConnection, typing.Dict[builtins.str, typing.Any]]]] = None,
    count: typing.Optional[typing.Union[jsii.Number, TerraformCount]] = None,
    depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
    for_each: typing.Optional[ITerraformIterator] = None,
    lifecycle: typing.Optional[typing.Union[TerraformResourceLifecycle, typing.Dict[builtins.str, typing.Any]]] = None,
    provider: typing.Optional[TerraformProvider] = None,
    provisioners: typing.Optional[typing.Sequence[typing.Union[typing.Union[FileProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[LocalExecProvisioner, typing.Dict[builtins.str, typing.Any]], typing.Union[RemoteExecProvisioner, typing.Dict[builtins.str, typing.Any]]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a1b28d14493d7002b4cbf3fb3200b1225371de6afb8c6c0d521d64d6caae5a43(
    x: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

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

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

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

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

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

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

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

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

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

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

def _typecheckingstub__2f94c678891e12174637ccbff2e0d9e5411b027282b4e021329fa621bac347f0(
    value: typing.Optional[typing.Union[jsii.Number, TerraformCount]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3b9d0c3a86c4a4515dd26cb231487a18a4b57a0c97a2e27b0257fb626ec827f2(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__79ddad63cdda152ee46a947839bcc90e4bc338b45dac19bd676cd9c54928e9a2(
    value: typing.Optional[ITerraformIterator],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__de278fe900c1b77867b14d06decdd63b05d5bf4e4c5383bcdcbbf74185da1f28(
    value: typing.Optional[TerraformResourceLifecycle],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8c7725e4968fe71a08ab51f1e6768295ade0c979611cce6fa8d80d5367bb70ce(
    value: typing.Optional[TerraformProvider],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__466cfc82d7fca4a515dce43e5e24509317c734e84d3d8c951224b8805ea2a9b9(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    variables: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    source: builtins.str,
    version: typing.Optional[builtins.str] = None,
    depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
    for_each: typing.Optional[ITerraformIterator] = None,
    providers: typing.Optional[typing.Sequence[typing.Union[TerraformProvider, typing.Union[TerraformModuleProvider, typing.Dict[builtins.str, typing.Any]]]]] = None,
    skip_asset_creation_from_local_modules: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

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

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

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

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

def _typecheckingstub__65438d4d11b541ac2ac28ec8857f5d0c3963e984384da07c6f33fba392cdaa77(
    variable: builtins.str,
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__060d43cd671b2ad8af16570ac8f9c32edd5be5e6966211fa28fc0bd314d330fd(
    *,
    depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
    for_each: typing.Optional[ITerraformIterator] = None,
    providers: typing.Optional[typing.Sequence[typing.Union[TerraformProvider, typing.Union[TerraformModuleProvider, typing.Dict[builtins.str, typing.Any]]]]] = None,
    skip_asset_creation_from_local_modules: typing.Optional[builtins.bool] = None,
    source: builtins.str,
    version: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6f4ca4759408d158b9485d1098c340519c34813b84b68c06e0a1710d1dca7ca7(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
    wraps_set: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9038dfad752950d49aff530ab1782b12dfb04b228005231d25abd071e86ad3ff(
    index: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__ee63ab762f58cc6485232a7fc8d16c1cca04b991ed8b1f4945682d390f69ebc7(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__201e67cd7c4a3f034bf7506954ea6c520c81cd984d6543f19721117114c785cc(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e731091bb1fcfdf5e69f850a305db13376224296ce6d172d5eaeedffef25f8a1(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

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

def _typecheckingstub__785dddd5038aecc05961a11a534a022cd8a0138bef1a49af1ca1365e65fc2d86(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d6bdabbc74cd7644b44c60771411e4c9df4352dceaada69796b967eba897eabd(
    scope: _constructs_77d1e7e8.Construct,
    *,
    container_name: builtins.str,
    key: builtins.str,
    storage_account_name: builtins.str,
    access_key: typing.Optional[builtins.str] = None,
    client_certificate_password: typing.Optional[builtins.str] = None,
    client_certificate_path: typing.Optional[builtins.str] = None,
    client_id: typing.Optional[builtins.str] = None,
    client_secret: typing.Optional[builtins.str] = None,
    endpoint: typing.Optional[builtins.str] = None,
    environment: typing.Optional[builtins.str] = None,
    metadata_host: typing.Optional[builtins.str] = None,
    msi_endpoint: typing.Optional[builtins.str] = None,
    oidc_request_token: typing.Optional[builtins.str] = None,
    oidc_request_url: typing.Optional[builtins.str] = None,
    oidc_token: typing.Optional[builtins.str] = None,
    oidc_token_file_path: typing.Optional[builtins.str] = None,
    resource_group_name: typing.Optional[builtins.str] = None,
    sas_token: typing.Optional[builtins.str] = None,
    snapshot: typing.Optional[builtins.bool] = None,
    subscription_id: typing.Optional[builtins.str] = None,
    tenant_id: typing.Optional[builtins.str] = None,
    use_azuread_auth: typing.Optional[builtins.bool] = None,
    use_microsoft_graph: typing.Optional[builtins.bool] = None,
    use_msi: typing.Optional[builtins.bool] = None,
    use_oidc: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c9650934422e67d1a4beb014a27383daa675f0830ba5fd25b1b0881ef460d255(
    scope: _constructs_77d1e7e8.Construct,
    name: builtins.str,
    _from_stack: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b9646960348a554bad8e6b9c1693d4e35a2223d9f87506aead823c421ad64418(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
    wraps_set: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__68eda82679aeb758e8687a139bf3ee5d2800f2243a901236e4b3cef260be02a5(
    index: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__698b09e675380c10ead3c5c311f9506414cc3ad235a9cc25f2361e0deab352e8(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b20bbabd07aa20d9a6514cf1654223a91e203e83e4f1eda90c27176373d17efe(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e7318d2496ae2fda0251b23d89a711c859c122533e98b2137d6108fb6914f997(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
    wraps_set: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__48249f4fcfcd1d9ca3b2a2b90f288c88f929d1883af88318c46f22627fe5b97d(
    index: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__f96d0bb549f495d0eab6b4fbcb03e3e8ae789c426eaa7b9d9ed0d7abcbe72b45(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3969245da87539a1af1854c78d5caaf0e723ab55b85769c48b294cc947eeb14e(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4ebade8ee10d996689b56a77f18fd4aeb40b11d195d19c34fe6f37b14df75111(
    terraform_resource: IInterpolatingParent,
    terraform_attribute: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

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

def _typecheckingstub__b7cf69d6dcd6e992a33d37bb8e8721e52187bc8638d2c285ef4a7caa08cbc8d3(
    value: IInterpolatingParent,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__331792c2de4604487f68c3740cbf3c0843a64da8281b0fa8973ceb13b823544e(
    scope: _constructs_77d1e7e8.Construct,
    *,
    organization: builtins.str,
    workspaces: typing.Union[NamedCloudWorkspace, TaggedCloudWorkspaces],
    hostname: typing.Optional[builtins.str] = None,
    token: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__29c24ef103ee5a50dc4cf9abe699150f94fde54257af601c4bc918c363500288(
    scope: _constructs_77d1e7e8.Construct,
    name: builtins.str,
    _from_stack: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1c0f04aaf6ad07d2cf1cf8126c98306e34215e156109553f4c51e66943d40041(
    scope: _constructs_77d1e7e8.Construct,
    *,
    access_token: builtins.str,
    path: builtins.str,
    address: typing.Optional[builtins.str] = None,
    ca_file: typing.Optional[builtins.str] = None,
    cert_file: typing.Optional[builtins.str] = None,
    datacenter: typing.Optional[builtins.str] = None,
    gzip: typing.Optional[builtins.bool] = None,
    http_auth: typing.Optional[builtins.str] = None,
    key_file: typing.Optional[builtins.str] = None,
    lock: typing.Optional[builtins.bool] = None,
    scheme: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d1d604635997895c64949524ea9cf4989df66b39f44f4e2967ce0c074b18a550(
    scope: _constructs_77d1e7e8.Construct,
    name: builtins.str,
    _from_stack: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2394cbc768287376b2da96c9afa8aec990b720def99495d34ab4f48efafa2553(
    scope: _constructs_77d1e7e8.Construct,
    *,
    bucket: builtins.str,
    accelerate: typing.Optional[builtins.bool] = None,
    acl: typing.Optional[builtins.str] = None,
    assume_role: typing.Optional[typing.Union[CosBackendAssumeRole, typing.Dict[builtins.str, typing.Any]]] = None,
    domain: typing.Optional[builtins.str] = None,
    encrypt: typing.Optional[builtins.bool] = None,
    endpoint: typing.Optional[builtins.str] = None,
    key: typing.Optional[builtins.str] = None,
    prefix: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    secret_id: typing.Optional[builtins.str] = None,
    secret_key: typing.Optional[builtins.str] = None,
    security_token: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__451d285c30124aec226ca021b899bb920d0d4c5e352d21a6ccc0f12c3b3036b0(
    scope: _constructs_77d1e7e8.Construct,
    name: builtins.str,
    _from_stack: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__719efb4389e7414eff4c0b125ef326f8d84f246be0facc93a1ec7b3c749638ca(
    list: typing.Union[typing.Sequence[builtins.str], IResolvable, typing.Sequence[jsii.Number], typing.Sequence[typing.Union[builtins.bool, IResolvable]]],
    map_key_attribute_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__baafae26b6a889becc40942b4e642fadedea6528655ef52c76baaa236bed7dd5(
    scope: _constructs_77d1e7e8.Construct,
    *,
    bucket: builtins.str,
    access_token: typing.Optional[builtins.str] = None,
    credentials: typing.Optional[builtins.str] = None,
    encryption_key: typing.Optional[builtins.str] = None,
    impersonate_service_account: typing.Optional[builtins.str] = None,
    impersonate_service_account_delegates: typing.Optional[typing.Sequence[builtins.str]] = None,
    kms_encryption_key: typing.Optional[builtins.str] = None,
    prefix: typing.Optional[builtins.str] = None,
    storeage_custom_endpoint: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d4c92042ee61291ae24b02195f9d57c4be65b0d43025cf71bb72e9109507d868(
    scope: _constructs_77d1e7e8.Construct,
    name: builtins.str,
    _from_stack: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cb23c48335c86e5c3266d50d65a674729ade9aae8e42685c16f39ecc1c426bd3(
    scope: _constructs_77d1e7e8.Construct,
    *,
    address: builtins.str,
    client_ca_certificate_pem: typing.Optional[builtins.str] = None,
    client_certificate_pem: typing.Optional[builtins.str] = None,
    client_private_key_pem: typing.Optional[builtins.str] = None,
    lock_address: typing.Optional[builtins.str] = None,
    lock_method: typing.Optional[builtins.str] = None,
    password: typing.Optional[builtins.str] = None,
    retry_max: typing.Optional[jsii.Number] = None,
    retry_wait_max: typing.Optional[jsii.Number] = None,
    retry_wait_min: typing.Optional[jsii.Number] = None,
    skip_cert_verification: typing.Optional[builtins.bool] = None,
    unlock_address: typing.Optional[builtins.str] = None,
    unlock_method: typing.Optional[builtins.str] = None,
    update_method: typing.Optional[builtins.str] = None,
    username: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3baeb366dadee6b13ee5c5aabc082edf54fc5d4869e870e45f1b1df87f6fe616(
    scope: _constructs_77d1e7e8.Construct,
    name: builtins.str,
    _from_stack: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__860cd4f6fc700209940bb21cd07a6577d543d0e77de9598c110fea15f6c9f7f2(
    scope: _constructs_77d1e7e8.Construct,
    *,
    path: typing.Optional[builtins.str] = None,
    workspace_dir: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fe6060cfa841d804b355096acd4084886a30d4df596da42f180e12d5978169bb(
    scope: _constructs_77d1e7e8.Construct,
    name: builtins.str,
    from_stack: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ae449e73ed2b213fd2f1632d9f3c6e00fbacd80d9a8f5a033c9a9217b3113929(
    scope: _constructs_77d1e7e8.Construct,
    *,
    bucket: builtins.str,
    access_key: typing.Optional[builtins.str] = None,
    acl: typing.Optional[builtins.str] = None,
    assume_role: typing.Optional[typing.Union[OssAssumeRole, typing.Dict[builtins.str, typing.Any]]] = None,
    assume_role_policy: typing.Optional[builtins.str] = None,
    assume_role_role_arn: typing.Optional[builtins.str] = None,
    assume_role_session_expiration: typing.Optional[jsii.Number] = None,
    assume_role_session_name: typing.Optional[builtins.str] = None,
    ecs_role_name: typing.Optional[builtins.str] = None,
    encrypt: typing.Optional[builtins.bool] = None,
    endpoint: typing.Optional[builtins.str] = None,
    key: typing.Optional[builtins.str] = None,
    prefix: typing.Optional[builtins.str] = None,
    profile: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    secret_key: typing.Optional[builtins.str] = None,
    security_token: typing.Optional[builtins.str] = None,
    shared_credentials_file: typing.Optional[builtins.str] = None,
    sts_endpoint: typing.Optional[builtins.str] = None,
    tablestore_endpoint: typing.Optional[builtins.str] = None,
    tablestore_table: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__73d96547aed7957cff901daf09712606a82d01e15ff92391d2ff5a47973ea87f(
    scope: _constructs_77d1e7e8.Construct,
    name: builtins.str,
    _from_stack: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__97fb1722ae8e5fdce1b872e63a314eac25a11aced7005ba54383a6bc1735c682(
    scope: _constructs_77d1e7e8.Construct,
    *,
    conn_str: builtins.str,
    schema_name: typing.Optional[builtins.str] = None,
    skip_index_creation: typing.Optional[builtins.bool] = None,
    skip_schema_creation: typing.Optional[builtins.bool] = None,
    skip_table_creation: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1dfb6f6ae50330a275e0d273ef1f77b9dd57a25c662b3bfc0a4f3daf8f6eee8b(
    scope: _constructs_77d1e7e8.Construct,
    name: builtins.str,
    _from_stack: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fb0d897bb4f2791521d8313101eb7c0d233f466883cf7a4168f3404a42038d44(
    scope: _constructs_77d1e7e8.Construct,
    *,
    organization: builtins.str,
    workspaces: IRemoteWorkspace,
    hostname: typing.Optional[builtins.str] = None,
    token: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__916a20c8f185c3b695f06f50af5791cd56649a4990bb89b8185197743ba910c9(
    scope: _constructs_77d1e7e8.Construct,
    name: builtins.str,
    _from_stack: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e38d6db5faac22bddc00a3c059dc3fc9e166d2cccc34df67a51fe136a3313a46(
    scope: _constructs_77d1e7e8.Construct,
    *,
    bucket: builtins.str,
    key: builtins.str,
    access_key: typing.Optional[builtins.str] = None,
    acl: typing.Optional[builtins.str] = None,
    allowed_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    assume_role: typing.Optional[typing.Union[S3BackendAssumeRoleConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    assume_role_policy: typing.Optional[builtins.str] = None,
    assume_role_policy_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
    assume_role_tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    assume_role_transitive_tag_keys: typing.Optional[typing.Sequence[builtins.str]] = None,
    assume_role_with_web_identity: typing.Optional[typing.Union[S3BackendAssumeRoleWithWebIdentityConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    custom_ca_bundle: typing.Optional[builtins.str] = None,
    dynamodb_endpoint: typing.Optional[builtins.str] = None,
    dynamodb_table: typing.Optional[builtins.str] = None,
    ec2_metadata_service_endpoint: typing.Optional[builtins.str] = None,
    ec2_metadata_service_endpoint_mode: typing.Optional[builtins.str] = None,
    encrypt: typing.Optional[builtins.bool] = None,
    endpoint: typing.Optional[builtins.str] = None,
    endpoints: typing.Optional[typing.Union[S3BackendEndpointConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    external_id: typing.Optional[builtins.str] = None,
    forbidden_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    force_path_style: typing.Optional[builtins.bool] = None,
    http_proxy: typing.Optional[builtins.str] = None,
    https_proxy: typing.Optional[builtins.str] = None,
    iam_endpoint: typing.Optional[builtins.str] = None,
    insecure: typing.Optional[builtins.bool] = None,
    kms_key_id: typing.Optional[builtins.str] = None,
    max_retries: typing.Optional[jsii.Number] = None,
    no_proxy: typing.Optional[builtins.str] = None,
    profile: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    retry_mode: typing.Optional[builtins.str] = None,
    role_arn: typing.Optional[builtins.str] = None,
    secret_key: typing.Optional[builtins.str] = None,
    session_name: typing.Optional[builtins.str] = None,
    shared_config_files: typing.Optional[typing.Sequence[builtins.str]] = None,
    shared_credentials_file: typing.Optional[builtins.str] = None,
    shared_credentials_files: typing.Optional[typing.Sequence[builtins.str]] = None,
    skip_credentials_validation: typing.Optional[builtins.bool] = None,
    skip_metadata_api_check: typing.Optional[builtins.bool] = None,
    skip_region_validation: typing.Optional[builtins.bool] = None,
    skip_requesting_account_id: typing.Optional[builtins.bool] = None,
    skip_s3_checksum: typing.Optional[builtins.bool] = None,
    sse_customer_key: typing.Optional[builtins.str] = None,
    sts_endpoint: typing.Optional[builtins.str] = None,
    sts_region: typing.Optional[builtins.str] = None,
    token: typing.Optional[builtins.str] = None,
    use_legacy_workflow: typing.Optional[builtins.bool] = None,
    use_path_style: typing.Optional[builtins.bool] = None,
    workspace_key_prefix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8b33c44bb01464cf0d7a43073924db216a5d043b619d26dbdfbd4cd27ae896e8(
    scope: _constructs_77d1e7e8.Construct,
    name: builtins.str,
    _from_stack: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__654caed6ba682d70ac0511d2cb9c3c6ffc8cd66bebdf8340f225574e23509a99(
    scope: _constructs_77d1e7e8.Construct,
    *,
    container: builtins.str,
    application_credential_id: typing.Optional[builtins.str] = None,
    application_credential_name: typing.Optional[builtins.str] = None,
    application_credential_secret: typing.Optional[builtins.str] = None,
    archive_container: typing.Optional[builtins.str] = None,
    auth_url: typing.Optional[builtins.str] = None,
    cacert_file: typing.Optional[builtins.str] = None,
    cert: typing.Optional[builtins.str] = None,
    cloud: typing.Optional[builtins.str] = None,
    default_domain: typing.Optional[builtins.str] = None,
    domain_id: typing.Optional[builtins.str] = None,
    domain_name: typing.Optional[builtins.str] = None,
    expire_after: typing.Optional[builtins.str] = None,
    insecure: typing.Optional[builtins.bool] = None,
    key: typing.Optional[builtins.str] = None,
    password: typing.Optional[builtins.str] = None,
    project_domain_id: typing.Optional[builtins.str] = None,
    project_domain_name: typing.Optional[builtins.str] = None,
    region_name: typing.Optional[builtins.str] = None,
    state_name: typing.Optional[builtins.str] = None,
    tenant_id: typing.Optional[builtins.str] = None,
    tenant_name: typing.Optional[builtins.str] = None,
    token: typing.Optional[builtins.str] = None,
    user_domain_id: typing.Optional[builtins.str] = None,
    user_domain_name: typing.Optional[builtins.str] = None,
    user_id: typing.Optional[builtins.str] = None,
    user_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__110786b9093e65c86e4119991a812b63af9aa024c2a4595d41ac4d71003c1789(
    scope: _constructs_77d1e7e8.Construct,
    name: builtins.str,
    _from_stack: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0930e68f78776f6767a34b896806a2c7f0841f069ff5f5b3f5b121addd24e2d3(
    *,
    depends_on: typing.Optional[typing.Sequence[ITerraformDependable]] = None,
    for_each: typing.Optional[ITerraformIterator] = None,
    providers: typing.Optional[typing.Sequence[typing.Union[TerraformProvider, typing.Union[TerraformModuleProvider, typing.Dict[builtins.str, typing.Any]]]]] = None,
    skip_asset_creation_from_local_modules: typing.Optional[builtins.bool] = None,
    source: builtins.str,
    version: typing.Optional[builtins.str] = None,
    variables: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
) -> None:
    """Type checking stubs"""
    pass
