@aws-cdk/core

  • Version 1.174.0
  • Published
  • 5.81 MB
  • 8 dependencies
  • Apache-2.0 license

Install

npm i @aws-cdk/core
yarn add @aws-cdk/core
pnpm add @aws-cdk/core

Overview

AWS Cloud Development Kit Core Library

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable booleanToCloudFormation

const booleanToCloudFormation: Mapper;

    variable BOOTSTRAP_QUALIFIER_CONTEXT

    const BOOTSTRAP_QUALIFIER_CONTEXT: string;

      variable numberToCloudFormation

      const numberToCloudFormation: Mapper;

        variable objectToCloudFormation

        const objectToCloudFormation: Mapper;

          variable STACK_RESOURCE_LIMIT_CONTEXT

          const STACK_RESOURCE_LIMIT_CONTEXT: string;

            variable stringToCloudFormation

            const stringToCloudFormation: Mapper;

              variable VALIDATION_SUCCESS

              const VALIDATION_SUCCESS: ValidationResult;

                Functions

                function attachCustomSynthesis

                attachCustomSynthesis: (
                construct: Construct,
                synthesis: ICustomSynthesis
                ) => void;
                • Add a custom synthesis for the given construct

                  When the construct is being synthesized, this allows it to add additional items into the Cloud Assembly output.

                  This feature is intended for use by official AWS CDK libraries only; 3rd party library authors and CDK users should not use this function. That's why it's not exposed via jsii.

                function canInspect

                canInspect: (x: any) => boolean;
                • Return whether this object can be validated at all

                  True unless it's undefined or a CloudFormation intrinsic

                function captureStackTrace

                captureStackTrace: (below?: Function, limit?: number) => string[];
                • Captures the current process' stack trace.

                  Stack traces are often invaluable tools to help diagnose problems, however their capture is a rather expensive operation, and the stack traces can be large. Consequently, users are stronly advised to condition capturing stack traces to specific user opt-in.

                  Stack traces will only be captured if the CDK_DEBUG environment variable is set to 'true' or 1.

                  Parameter below

                  an optional function starting from which stack frames will be ignored. Defaults to the captureStackTrace function itself.

                  Parameter limit

                  and optional upper bound to the number of stack frames to be captured. If not provided, this defaults to Number.MAX_SAFE_INTEGER, effectively meaning "no limit".

                  Returns

                  the captured stack trace, as an array of stack frames.

                function cfnTagToCloudFormation

                cfnTagToCloudFormation: (x: any) => any;
                • Turn a tag object into the proper CloudFormation representation

                function dateToCloudFormation

                dateToCloudFormation: (x?: Date) => any;
                • The date needs to be formatted as an ISO date in UTC

                  Some usage sites require a date, some require a timestamp. We'll always output a timestamp and hope the parser on the other end is smart enough to ignore the time part... (?)

                function hashMapper

                hashMapper: (elementMapper: Mapper) => Mapper;

                  function hashValidator

                  hashValidator: (elementValidator: Validator) => Validator;
                  • Return a hash validator based on the given element validator

                  function isResolvableObject

                  isResolvableObject: (x: any) => x is IResolvable;

                    function listMapper

                    listMapper: (elementMapper: Mapper) => Mapper;

                      function listValidator

                      listValidator: (elementValidator: Validator) => Validator;
                      • Return a list validator based on the given element validator

                      function propertyValidator

                      propertyValidator: (propName: string, validator: Validator) => Validator;
                      • Decorate a validator with a message clarifying the property the failure is for.

                      function requiredValidator

                      requiredValidator: (x: any) => ValidationResult;
                      • Return a validator that will fail if the passed property is not present

                        Does not distinguish between the property actually not being present, vs being present but 'null' or 'undefined' (courtesy of JavaScript), which is generally the behavior that we want.

                        Empty strings are considered "present"--don't know if this agrees with how CloudFormation looks at the world.

                      function requireProperty

                      requireProperty: (
                      props: { [name: string]: any },
                      name: string,
                      context: Construct
                      ) => any;
                      • Require a property from a property bag.

                        Parameter props

                        the property bag from which a property is required.

                        Parameter name

                        the name of the required property.

                        Parameter typeName

                        the name of the construct type that requires the property

                        Returns

                        the value of ``props[name]``

                        Throws

                        if the property ``name`` is not present in ``props``.

                      function rootPathTo

                      rootPathTo: (construct: IConstruct, ancestor?: IConstruct) => IConstruct[];
                      • Return the construct root path of the given construct relative to the given ancestor

                        If no ancestor is given or the ancestor is not found, return the entire root path.

                      function unionMapper

                      unionMapper: (validators: Validator[], mappers: Mapper[]) => Mapper;
                      • Return a union mapper

                        Takes a list of validators and a list of mappers, which should correspond pairwise.

                        The mapper of the first successful validator will be called.

                      function unionValidator

                      unionValidator: (...validators: Validator[]) => Validator;
                      • Validates if any of the given validators matches

                        We add either/or words to the front of the error mesages so that they read more nicely. Example:

                        Properties not correct for 'FunctionProps' codeUri: not one of the possible types either: properties not correct for 'S3LocationProperty' bucket: required but missing key: required but missing version: required but missing or: '3' should be a 'string'

                      function validateBoolean

                      validateBoolean: (x: any) => ValidationResult;

                        function validateCfnTag

                        validateCfnTag: (x: any) => ValidationResult;

                          function validateDate

                          validateDate: (x: any) => ValidationResult;

                            function validateNumber

                            validateNumber: (x: any) => ValidationResult;

                              function validateObject

                              validateObject: (x: any) => ValidationResult;

                                function validateString

                                validateString: (x: any) => ValidationResult;

                                  function withResolved

                                  withResolved: {
                                  <A>(a: A, fn: (a: A) => void): void;
                                  <A, B>(a: A, b: B, fn: (a: A, b: B) => void): void;
                                  <A, B, C>(a: A, b: B, c: C, fn: (a: A, b: B, c: C) => void): void;
                                  };
                                  • Call the given function only if all given values are resolved

                                    Exported as a function since it will be used by TypeScript modules, but can't be exposed via JSII because of the generics.

                                  Classes

                                  class Annotations

                                  class Annotations {}
                                  • Includes API for attaching annotations such as warning messages to constructs.

                                  method addDeprecation

                                  addDeprecation: (api: string, message: string) => void;
                                  • Adds a deprecation warning for a specific API.

                                    Deprecations will be added only once per construct as a warning and will be deduplicated based on the api.

                                    If the environment variable CDK_BLOCK_DEPRECATIONS is set, this method will throw an error instead with the deprecation message.

                                    Parameter api

                                    The API being deprecated in the format module.Class.property (e.g. @aws-cdk/core.Construct.node).

                                    Parameter message

                                    The deprecation message to display, with information about alternatives.

                                  method addError

                                  addError: (message: string) => void;
                                  • Adds an { "error": } metadata entry to this construct. The toolkit will fail deployment of any stack that has errors reported against it.

                                    Parameter message

                                    The error message.

                                  method addInfo

                                  addInfo: (message: string) => void;
                                  • Adds an info metadata entry to this construct.

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

                                    Parameter message

                                    The info message.

                                  method addWarning

                                  addWarning: (message: string) => void;
                                  • Adds a warning metadata entry to this construct.

                                    The CLI will display the warning when an app is synthesized, or fail if run in --strict mode.

                                    Parameter message

                                    The warning message.

                                  method of

                                  static of: (scope: IConstruct) => Annotations;
                                  • Returns the annotations API for a construct scope.

                                    Parameter scope

                                    The scope

                                  class App

                                  class App extends Stage {}
                                  • A construct which represents an entire CDK app. This construct is normally the root of the construct tree.

                                    You would normally define an App instance in your program's entrypoint, then define constructs where the app is used as the parent scope.

                                    After all the child constructs are defined within the app, you should call app.synth() which will emit a "cloud assembly" from this app into the directory specified by outdir. Cloud assemblies includes artifacts such as CloudFormation templates and assets that are needed to deploy this app into the AWS cloud.

                                    See Also

                                    • https://docs.aws.amazon.com/cdk/latest/guide/apps.html

                                  constructor

                                  constructor(props?: AppProps);
                                  • Initializes a CDK application.

                                    Parameter props

                                    initialization properties

                                  method isApp

                                  static isApp: (obj: any) => obj is App;
                                  • Checks if an object is an instance of the App class.

                                    Parameter obj

                                    The object to evaluate

                                    Returns

                                    true if obj is an App.

                                  class Arn

                                  class Arn {}

                                    method extractResourceName

                                    static extractResourceName: (arn: string, resourceType: string) => string;
                                    • Extract the full resource name from an ARN

                                      Necessary for resource names (paths) that may contain the separator, like arn:aws:iam::111111111111:role/path/to/role/name.

                                      Only works if we statically know the expected resourceType beforehand, since we're going to use that to split the string on ':/' (and take the right-hand side).

                                      We can't extract the 'resourceType' from the ARN at hand, because CloudFormation Expressions only allow literals in the 'separator' argument to { Fn::Split }, and so it can't be { Fn::Select: [5, { Fn::Split: [':', ARN] }}.

                                      Only necessary for ARN formats for which the type-name separator is /.

                                    method format

                                    static format: (components: ArnComponents, stack?: Stack) => string;
                                    • Creates an ARN from components.

                                      If partition, region or account are not specified, the stack's partition, region and account will be used.

                                      If any component is the empty string, an empty string will be inserted into the generated ARN at the location that component corresponds to.

                                      The ARN will be formatted as follows:

                                      arn:{partition}:{service}:{region}:{account}:{resource}{sep}{resource-name}

                                      The required ARN pieces that are omitted will be taken from the stack that the 'scope' is attached to. If all ARN pieces are supplied, the supplied scope can be 'undefined'.

                                    method parse

                                    static parse: (
                                    arn: string,
                                    sepIfToken?: string,
                                    hasName?: boolean
                                    ) => ArnComponents;
                                    • Given an ARN, parses it and returns components.

                                      IF THE ARN IS A CONCRETE STRING...

                                      ...it will be parsed and validated. The separator (sep) will be set to '/' if the 6th component includes a '/', in which case, resource will be set to the value before the '/' and resourceName will be the rest. In case there is no '/', resource will be set to the 6th components and resourceName will be set to the rest of the string.

                                      IF THE ARN IS A TOKEN...

                                      ...it cannot be validated, since we don't have the actual value yet at the time of this function call. You will have to supply sepIfToken and whether or not ARNs of the expected format usually have resource names in order to parse it properly. The resulting ArnComponents object will contain tokens for the subexpressions of the ARN, not string literals.

                                      If the resource name could possibly contain the separator char, the actual resource name cannot be properly parsed. This only occurs if the separator char is '/', and happens for example for S3 object ARNs, IAM Role ARNs, IAM OIDC Provider ARNs, etc. To properly extract the resource name from a Tokenized ARN, you must know the resource type and call Arn.extractResourceName.

                                      Parameter arn

                                      The ARN to parse

                                      Parameter sepIfToken

                                      The separator used to separate resource from resourceName

                                      Parameter hasName

                                      Whether there is a name component in the ARN at all. For example, SNS Topics ARNs have the 'resource' component contain the topic name, and no 'resourceName' component.

                                      Returns

                                      an ArnComponents object which allows access to the various components of the ARN.

                                      Deprecated

                                      use split instead

                                    method split

                                    static split: (arn: string, arnFormat: ArnFormat) => ArnComponents;
                                    • Splits the provided ARN into its components. Works both if 'arn' is a string like 'arn:aws:s3:::bucket', and a Token representing a dynamic CloudFormation expression (in which case the returned components will also be dynamic CloudFormation expressions, encoded as Tokens).

                                      Parameter arn

                                      the ARN to split into its components

                                      Parameter arnFormat

                                      the expected format of 'arn' - depends on what format the service 'arn' represents uses

                                    class Aspects

                                    class Aspects {}
                                    • Aspects can be applied to CDK tree scopes and can operate on the tree before synthesis.

                                    property aspects

                                    readonly aspects: IAspect[];
                                    • The list of aspects which were directly applied on this scope.

                                    method add

                                    add: (aspect: IAspect) => void;
                                    • Adds an aspect to apply this scope before synthesis.

                                      Parameter aspect

                                      The aspect to add.

                                    method of

                                    static of: (scope: IConstruct) => Aspects;
                                    • Returns the Aspects object associated with a construct scope.

                                      Parameter scope

                                      The scope for which these aspects will apply.

                                    class AssetStaging

                                    class AssetStaging extends CoreConstruct {}
                                    • Stages a file or directory from a location on the file system into a staging directory.

                                      This is controlled by the context key 'aws:cdk:asset-staging' and enabled by the CLI by default in order to ensure that when the CDK app exists, all assets are available for deployment. Otherwise, if an app references assets in temporary locations, those will not be available when it exists (see https://github.com/aws/aws-cdk/issues/1716).

                                      The stagedPath property is a stringified token that represents the location of the file or directory after staging. It will be resolved only during the "prepare" stage and may be either the original path or the staged path depending on the context setting.

                                      The file/directory are staged based on their content hash (fingerprint). This means that only if content was changed, copy will happen.

                                    constructor

                                    constructor(scope: Construct, id: string, props: AssetStagingProps);

                                      property absoluteStagedPath

                                      readonly absoluteStagedPath: string;
                                      • Absolute path to the asset data.

                                        If asset staging is disabled, this will just be the source path or a temporary directory used for bundling.

                                        If asset staging is enabled it will be the staged path.

                                        IMPORTANT: If you are going to call addFileAsset(), use relativeStagedPath() instead.

                                      property assetHash

                                      readonly assetHash: string;
                                      • A cryptographic hash of the asset.

                                      property BUNDLING_INPUT_DIR

                                      static readonly BUNDLING_INPUT_DIR: string;
                                      • The directory inside the bundling container into which the asset sources will be mounted.

                                      property BUNDLING_OUTPUT_DIR

                                      static readonly BUNDLING_OUTPUT_DIR: string;
                                      • The directory inside the bundling container into which the bundled output should be written.

                                      property isArchive

                                      readonly isArchive: boolean;
                                      • Whether this asset is an archive (zip or jar).

                                      property packaging

                                      readonly packaging: FileAssetPackaging;
                                      • How this asset should be packaged.

                                      property sourceHash

                                      readonly sourceHash: string;
                                      • A cryptographic hash of the asset.

                                        Deprecated

                                        see assetHash.

                                      property sourcePath

                                      readonly sourcePath: string;
                                      • The absolute path of the asset as it was referenced by the user.

                                      property stagedPath

                                      readonly stagedPath: string;
                                      • Absolute path to the asset data.

                                        If asset staging is disabled, this will just be the source path or a temporary directory used for bundling.

                                        If asset staging is enabled it will be the staged path.

                                        IMPORTANT: If you are going to call addFileAsset(), use relativeStagedPath() instead.

                                        Deprecated

                                        - Use absoluteStagedPath instead.

                                      method clearAssetHashCache

                                      static clearAssetHashCache: () => void;
                                      • Clears the asset hash cache

                                      method relativeStagedPath

                                      relativeStagedPath: (stack: Stack) => string;
                                      • Return the path to the staged asset, relative to the Cloud Assembly (manifest) directory of the given stack

                                        Only returns a relative path if the asset was staged, returns an absolute path if it was not staged.

                                        A bundled asset might end up in the outDir and still not count as "staged"; if asset staging is disabled we're technically expected to reference source directories, but we don't have a source directory for the bundled outputs (as the bundle output is written to a temporary directory). Nevertheless, we will still return an absolute path.

                                        A non-obvious directory layout may look like this:

                                        CLOUD ASSEMBLY ROOT
                                        +-- asset.12345abcdef/
                                        +-- assembly-Stage
                                        +-- MyStack.template.json
                                        +-- MyStack.assets.json <- will contain { "path": "../asset.12345abcdef" }

                                      class Aws

                                      class Aws {}
                                      • Accessor for pseudo parameters

                                        Since pseudo parameters need to be anchored to a stack somewhere in the construct tree, this class takes an scope parameter; the pseudo parameter values can be obtained as properties from an scoped object.

                                      property ACCOUNT_ID

                                      static readonly ACCOUNT_ID: string;

                                        property NO_VALUE

                                        static readonly NO_VALUE: string;

                                          property NOTIFICATION_ARNS

                                          static readonly NOTIFICATION_ARNS: string[];

                                            property PARTITION

                                            static readonly PARTITION: string;

                                              property REGION

                                              static readonly REGION: string;

                                                property STACK_ID

                                                static readonly STACK_ID: string;

                                                  property STACK_NAME

                                                  static readonly STACK_NAME: string;

                                                    property URL_SUFFIX

                                                    static readonly URL_SUFFIX: string;

                                                      class BootstraplessSynthesizer

                                                      class BootstraplessSynthesizer extends DefaultStackSynthesizer {}
                                                      • Synthesizer that reuses bootstrap roles from a different region

                                                        A special synthesizer that behaves similarly to DefaultStackSynthesizer, but doesn't require bootstrapping the environment it operates in. Instead, it will re-use the Roles that were created for a different region (which is possible because IAM is a global service).

                                                        However, it will not assume asset buckets or repositories have been created, and therefore does not support assets.

                                                        Used by the CodePipeline construct for the support stacks needed for cross-region replication S3 buckets. App builders do not need to use this synthesizer directly.

                                                      constructor

                                                      constructor(props: BootstraplessSynthesizerProps);

                                                        method addDockerImageAsset

                                                        addDockerImageAsset: (
                                                        _asset: DockerImageAssetSource
                                                        ) => DockerImageAssetLocation;

                                                          method addFileAsset

                                                          addFileAsset: (_asset: FileAssetSource) => FileAssetLocation;

                                                            method synthesize

                                                            synthesize: (session: ISynthesisSession) => void;

                                                              class BundlingDockerImage

                                                              class BundlingDockerImage {}
                                                              • A Docker image used for asset bundling

                                                                Deprecated

                                                                use DockerImage

                                                              constructor

                                                              protected constructor(image: string, _imageHash?: string);
                                                              • Parameter image

                                                                The Docker image

                                                              property image

                                                              readonly image: string;

                                                                method cp

                                                                cp: (imagePath: string, outputPath?: string) => string;
                                                                • Copies a file or directory out of the Docker image to the local filesystem.

                                                                  If outputPath is omitted the destination path is a temporary directory.

                                                                  Parameter imagePath

                                                                  the path in the Docker image

                                                                  Parameter outputPath

                                                                  the destination path for the copy operation

                                                                  Returns

                                                                  the destination path

                                                                method fromAsset

                                                                static fromAsset: (
                                                                path: string,
                                                                options?: DockerBuildOptions
                                                                ) => BundlingDockerImage;
                                                                • Reference an image that's built directly from sources on disk.

                                                                  Parameter path

                                                                  The path to the directory containing the Docker file

                                                                  Parameter options

                                                                  Docker build options

                                                                  Deprecated

                                                                  use DockerImage.fromBuild()

                                                                method fromRegistry

                                                                static fromRegistry: (image: string) => DockerImage;
                                                                • Reference an image on DockerHub or another online registry.

                                                                  Parameter image

                                                                  the image name

                                                                method run

                                                                run: (options?: DockerRunOptions) => void;
                                                                • Runs a Docker image

                                                                method toJSON

                                                                toJSON: () => string;
                                                                • Provides a stable representation of this image for JSON serialization.

                                                                  The overridden image name if set or image hash name in that order

                                                                class CfnCodeDeployBlueGreenHook

                                                                class CfnCodeDeployBlueGreenHook extends CfnHook {}
                                                                • A CloudFormation Hook for CodeDeploy blue-green ECS deployments.

                                                                  See Also

                                                                  • https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html#blue-green-template-reference

                                                                constructor

                                                                constructor(
                                                                scope: Construct,
                                                                id: string,
                                                                props: CfnCodeDeployBlueGreenHookProps
                                                                );
                                                                • Creates a new CodeDeploy blue-green ECS Hook.

                                                                  Parameter scope

                                                                  the scope to create the hook in (usually the containing Stack object)

                                                                  Parameter id

                                                                  the identifier of the construct - will be used to generate the logical ID of the Hook

                                                                  Parameter props

                                                                  the properties of the Hook

                                                                property additionalOptions

                                                                additionalOptions: CfnCodeDeployBlueGreenAdditionalOptions;
                                                                • Additional options for the blue/green deployment.

                                                                  - no additional options

                                                                property applications

                                                                applications: CfnCodeDeployBlueGreenApplication[];
                                                                • Properties of the Amazon ECS applications being deployed.

                                                                property lifecycleEventHooks

                                                                lifecycleEventHooks: CfnCodeDeployBlueGreenLifecycleEventHooks;
                                                                • Use lifecycle event hooks to specify a Lambda function that CodeDeploy can call to validate a deployment. You can use the same function or a different one for deployment lifecycle events. Following completion of the validation tests, the Lambda CfnCodeDeployBlueGreenLifecycleEventHooks.afterAllowTraffic function calls back CodeDeploy and delivers a result of 'Succeeded' or 'Failed'.

                                                                  - no lifecycle event hooks

                                                                property serviceRole

                                                                serviceRole: string;
                                                                • The IAM Role for CloudFormation to use to perform blue-green deployments.

                                                                property trafficRoutingConfig

                                                                trafficRoutingConfig: CfnTrafficRoutingConfig;
                                                                • Traffic routing configuration settings.

                                                                  - time-based canary traffic shifting, with a 15% step percentage and a five minute bake time

                                                                method renderProperties

                                                                protected renderProperties: (_props?: { [p: string]: any }) => {
                                                                [p: string]: any;
                                                                };

                                                                  class CfnCondition

                                                                  class CfnCondition
                                                                  extends CfnElement
                                                                  implements ICfnConditionExpression, IResolvable {}
                                                                  • Represents a CloudFormation condition, for resources which must be conditionally created and the determination must be made at deploy time.

                                                                  constructor

                                                                  constructor(scope: Construct, id: string, props?: CfnConditionProps);
                                                                  • Build a new condition. The condition must be constructed with a condition token, that the condition is based on.

                                                                  property expression

                                                                  expression?: ICfnConditionExpression;
                                                                  • The condition statement.

                                                                  method resolve

                                                                  resolve: (_context: IResolveContext) => any;
                                                                  • Synthesizes the condition.

                                                                  class CfnCustomResource

                                                                  class CfnCustomResource extends cdk.CfnResource implements cdk.IInspectable {}
                                                                  • A CloudFormation AWS::CloudFormation::CustomResource

                                                                    In a CloudFormation template, you use the AWS::CloudFormation::CustomResource or Custom:: *String* resource type to specify custom resources.

                                                                    Custom resources provide a way for you to write custom provisioning logic in CloudFormation template and have CloudFormation run it during a stack operation, such as when you create, update or delete a stack. For more information, see [Custom resources](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-custom-resources.html) .

                                                                    > If you use the [VPC endpoints](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html) feature, custom resources in the VPC must have access to CloudFormation -specific Amazon Simple Storage Service ( Amazon S3 ) buckets. Custom resources must send responses to a presigned Amazon S3 URL. If they can't send responses to Amazon S3 , CloudFormation won't receive a response and the stack operation fails. For more information, see [Setting up VPC endpoints for AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-vpce-bucketnames.html) .

                                                                    AWS::CloudFormation::CustomResource external

                                                                    http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cfn-customresource.html

                                                                  constructor

                                                                  constructor(scope: cdk.Construct, id: string, props: cdk.CfnCustomResourceProps);
                                                                  • Create a new AWS::CloudFormation::CustomResource.

                                                                    Parameter scope

                                                                    scope in which this resource is defined

                                                                    Parameter id

                                                                    scoped id of the resource

                                                                    Parameter props

                                                                    resource properties

                                                                  property CFN_RESOURCE_TYPE_NAME

                                                                  static readonly CFN_RESOURCE_TYPE_NAME: string;
                                                                  • The CloudFormation resource type name for this resource class.

                                                                  property cfnProperties

                                                                  readonly cfnProperties: { [key: string]: any };

                                                                    property serviceToken

                                                                    serviceToken: string;
                                                                    • > Only one property is defined by AWS for a custom resource: ServiceToken . All other properties are defined by the service provider.

                                                                      The service token that was given to the template developer by the service provider to access the service, such as an Amazon SNS topic ARN or Lambda function ARN. The service token must be from the same Region in which you are creating the stack.

                                                                      Updates aren't supported.

                                                                      http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cfn-customresource.html#cfn-customresource-servicetoken

                                                                    method inspect

                                                                    inspect: (inspector: cdk.TreeInspector) => void;
                                                                    • Examines the CloudFormation resource and discloses attributes.

                                                                      Parameter inspector

                                                                      tree inspector to collect and process attributes

                                                                    method renderProperties

                                                                    protected renderProperties: (props: { [key: string]: any }) => {
                                                                    [key: string]: any;
                                                                    };

                                                                      class CfnDynamicReference

                                                                      class CfnDynamicReference extends Intrinsic {}
                                                                      • References a dynamically retrieved value

                                                                        This is a Construct so that subclasses will (eventually) be able to attach metadata to themselves without having to change call signatures.

                                                                        See Also

                                                                        • https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html

                                                                      constructor

                                                                      constructor(service: CfnDynamicReferenceService, key: string);

                                                                        class CfnElement

                                                                        abstract class CfnElement extends CoreConstruct {}
                                                                        • An element of a CloudFormation stack.

                                                                        constructor

                                                                        constructor(scope: Construct, id: string);
                                                                        • Creates an entity and binds it to a tree. Note that the root of the tree must be a Stack object (not just any Root).

                                                                          Parameter scope

                                                                          The parent construct

                                                                          Parameter props

                                                                          Construct properties

                                                                        property creationStack

                                                                        readonly creationStack: string[];
                                                                        • Returns

                                                                          the stack trace of the point where this Resource was created from, sourced from the +metadata+ entry typed +aws:cdk:logicalId+, and with the bottom-most node +internal+ entries filtered.

                                                                        property logicalId

                                                                        readonly logicalId: string;
                                                                        • The logical ID for this CloudFormation stack element. The logical ID of the element is calculated from the path of the resource node in the construct tree.

                                                                          To override this value, use overrideLogicalId(newLogicalId).

                                                                          Returns

                                                                          the logical ID as a stringified token. This value will only get resolved during synthesis.

                                                                        property stack

                                                                        readonly stack: Stack;
                                                                        • The stack in which this element is defined. CfnElements must be defined within a stack scope (directly or indirectly).

                                                                        method isCfnElement

                                                                        static isCfnElement: (x: any) => x is CfnElement;
                                                                        • Returns true if a construct is a stack element (i.e. part of the synthesized cloudformation template).

                                                                          Uses duck-typing instead of instanceof to allow stack elements from different versions of this library to be included in the same stack.

                                                                          Returns

                                                                          The construct as a stack element or undefined if it is not a stack element.

                                                                        method overrideLogicalId

                                                                        overrideLogicalId: (newLogicalId: string) => void;
                                                                        • Overrides the auto-generated logical ID with a specific ID.

                                                                          Parameter newLogicalId

                                                                          The new logical ID to use for this stack element.

                                                                        class CfnHook

                                                                        class CfnHook extends CfnElement {}
                                                                        • Represents a CloudFormation resource.

                                                                        constructor

                                                                        constructor(scope: Construct, id: string, props: CfnHookProps);
                                                                        • Creates a new Hook object.

                                                                        property type

                                                                        readonly type: string;
                                                                        • The type of the hook (for example, "AWS::CodeDeploy::BlueGreen").

                                                                        method renderProperties

                                                                        protected renderProperties: (props?: { [key: string]: any }) => {
                                                                        [key: string]: any;
                                                                        };

                                                                          class CfnHookDefaultVersion

                                                                          class CfnHookDefaultVersion extends cdk.CfnResource implements cdk.IInspectable {}
                                                                          • A CloudFormation AWS::CloudFormation::HookDefaultVersion

                                                                            The HookDefaultVersion resource specifies the default version of the hook. The default version of the hook is used in CloudFormation operations for this AWS account and AWS Region .

                                                                            AWS::CloudFormation::HookDefaultVersion external

                                                                            http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-hookdefaultversion.html

                                                                          constructor

                                                                          constructor(
                                                                          scope: cdk.Construct,
                                                                          id: string,
                                                                          props?: cdk.CfnHookDefaultVersionProps
                                                                          );
                                                                          • Create a new AWS::CloudFormation::HookDefaultVersion.

                                                                            Parameter scope

                                                                            scope in which this resource is defined

                                                                            Parameter id

                                                                            scoped id of the resource

                                                                            Parameter props

                                                                            resource properties

                                                                          property attrArn

                                                                          readonly attrArn: string;
                                                                          • The Amazon Resource Number (ARN) of the activated extension, in this account and Region. Arn

                                                                          property CFN_RESOURCE_TYPE_NAME

                                                                          static readonly CFN_RESOURCE_TYPE_NAME: string;
                                                                          • The CloudFormation resource type name for this resource class.

                                                                          property cfnProperties

                                                                          readonly cfnProperties: { [key: string]: any };

                                                                            property typeName

                                                                            typeName: string;
                                                                            • The name of the hook.

                                                                              You must specify either TypeVersionArn , or TypeName and VersionId .

                                                                              http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-hookdefaultversion.html#cfn-cloudformation-hookdefaultversion-typename

                                                                            property typeVersionArn

                                                                            typeVersionArn: string;
                                                                            • The version ID of the type configuration.

                                                                              You must specify either TypeVersionArn , or TypeName and VersionId .

                                                                              http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-hookdefaultversion.html#cfn-cloudformation-hookdefaultversion-typeversionarn

                                                                            property versionId

                                                                            versionId: string;
                                                                            • The version ID of the type specified.

                                                                              You must specify either TypeVersionArn , or TypeName and VersionId .

                                                                              http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-hookdefaultversion.html#cfn-cloudformation-hookdefaultversion-versionid

                                                                            method inspect

                                                                            inspect: (inspector: cdk.TreeInspector) => void;
                                                                            • Examines the CloudFormation resource and discloses attributes.

                                                                              Parameter inspector

                                                                              tree inspector to collect and process attributes

                                                                            method renderProperties

                                                                            protected renderProperties: (props: { [key: string]: any }) => {
                                                                            [key: string]: any;
                                                                            };

                                                                              class CfnHookTypeConfig

                                                                              class CfnHookTypeConfig extends cdk.CfnResource implements cdk.IInspectable {}
                                                                              • A CloudFormation AWS::CloudFormation::HookTypeConfig

                                                                                The HookTypeConfig resource specifies the configuration of a hook.

                                                                                AWS::CloudFormation::HookTypeConfig external

                                                                                http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-hooktypeconfig.html

                                                                              constructor

                                                                              constructor(scope: cdk.Construct, id: string, props: cdk.CfnHookTypeConfigProps);
                                                                              • Create a new AWS::CloudFormation::HookTypeConfig.

                                                                                Parameter scope

                                                                                scope in which this resource is defined

                                                                                Parameter id

                                                                                scoped id of the resource

                                                                                Parameter props

                                                                                resource properties

                                                                              property attrConfigurationArn

                                                                              readonly attrConfigurationArn: string;
                                                                              • The Amazon Resource Number (ARN) of the activated hook type configuration, in this account and Region. ConfigurationArn

                                                                              property CFN_RESOURCE_TYPE_NAME

                                                                              static readonly CFN_RESOURCE_TYPE_NAME: string;
                                                                              • The CloudFormation resource type name for this resource class.

                                                                              property cfnProperties

                                                                              readonly cfnProperties: { [key: string]: any };

                                                                                property configuration

                                                                                configuration: string;
                                                                                • Specifies the activated hook type configuration, in this AWS account and AWS Region .

                                                                                  You must specify either TypeName and Configuration or TypeARN and Configuration .

                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-hooktypeconfig.html#cfn-cloudformation-hooktypeconfig-configuration

                                                                                property configurationAlias

                                                                                configurationAlias: string;
                                                                                • Specifies the activated hook type configuration, in this AWS account and AWS Region .

                                                                                  Defaults to default alias. Hook types currently support default configuration alias.

                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-hooktypeconfig.html#cfn-cloudformation-hooktypeconfig-configurationalias

                                                                                property typeArn

                                                                                typeArn: string;
                                                                                • The Amazon Resource Number (ARN) for the hook to set Configuration for.

                                                                                  You must specify either TypeName and Configuration or TypeARN and Configuration .

                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-hooktypeconfig.html#cfn-cloudformation-hooktypeconfig-typearn

                                                                                property typeName

                                                                                typeName: string;
                                                                                • The unique name for your hook. Specifies a three-part namespace for your hook, with a recommended pattern of Organization::Service::Hook .

                                                                                  You must specify either TypeName and Configuration or TypeARN and Configuration .

                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-hooktypeconfig.html#cfn-cloudformation-hooktypeconfig-typename

                                                                                method inspect

                                                                                inspect: (inspector: cdk.TreeInspector) => void;
                                                                                • Examines the CloudFormation resource and discloses attributes.

                                                                                  Parameter inspector

                                                                                  tree inspector to collect and process attributes

                                                                                method renderProperties

                                                                                protected renderProperties: (props: { [key: string]: any }) => {
                                                                                [key: string]: any;
                                                                                };

                                                                                  class CfnHookVersion

                                                                                  class CfnHookVersion extends cdk.CfnResource implements cdk.IInspectable {}
                                                                                  • A CloudFormation AWS::CloudFormation::HookVersion

                                                                                    The HookVersion resource publishes new or first hook version to the AWS CloudFormation registry.

                                                                                    AWS::CloudFormation::HookVersion external

                                                                                    http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-hookversion.html

                                                                                  constructor

                                                                                  constructor(scope: cdk.Construct, id: string, props: cdk.CfnHookVersionProps);
                                                                                  • Create a new AWS::CloudFormation::HookVersion.

                                                                                    Parameter scope

                                                                                    scope in which this resource is defined

                                                                                    Parameter id

                                                                                    scoped id of the resource

                                                                                    Parameter props

                                                                                    resource properties

                                                                                  property attrArn

                                                                                  readonly attrArn: string;
                                                                                  • The Amazon Resource Name (ARN) of the hook. Arn

                                                                                  property attrIsDefaultVersion

                                                                                  readonly attrIsDefaultVersion: cdk.IResolvable;
                                                                                  • Whether the specified hook version is set as the default version. IsDefaultVersion

                                                                                  property attrTypeArn

                                                                                  readonly attrTypeArn: string;
                                                                                  • The Amazon Resource Number (ARN) assigned to this version of the hook. TypeArn

                                                                                  property attrVersionId

                                                                                  readonly attrVersionId: string;
                                                                                  • The ID of this version of the hook. VersionId

                                                                                  property attrVisibility

                                                                                  readonly attrVisibility: string;
                                                                                  • The scope at which the resource is visible and usable in CloudFormation operations.

                                                                                    Valid values include:

                                                                                    - PRIVATE : The resource is only visible and usable within the account in which it's registered. CloudFormation marks any resources you register as PRIVATE . - PUBLIC : The resource is publicly visible and usable within any Amazon account. Visibility

                                                                                  property CFN_RESOURCE_TYPE_NAME

                                                                                  static readonly CFN_RESOURCE_TYPE_NAME: string;
                                                                                  • The CloudFormation resource type name for this resource class.

                                                                                  property cfnProperties

                                                                                  readonly cfnProperties: { [key: string]: any };

                                                                                    property executionRoleArn

                                                                                    executionRoleArn: string;
                                                                                    • The Amazon Resource Name (ARN) of the task execution role that grants the hook permission.

                                                                                      http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-hookversion.html#cfn-cloudformation-hookversion-executionrolearn

                                                                                    property loggingConfig

                                                                                    loggingConfig: cdk.IResolvable | cdk.CfnHookVersion.LoggingConfigProperty;
                                                                                    • Contains logging configuration information for an extension.

                                                                                      http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-hookversion.html#cfn-cloudformation-hookversion-loggingconfig

                                                                                    property schemaHandlerPackage

                                                                                    schemaHandlerPackage: string;
                                                                                    • A URL to the Amazon S3 bucket containing the hook project package that contains the necessary files for the hook you want to register.

                                                                                      For information on generating a schema handler package for the resource you want to register, see [submit](https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-type-cli-submit.html) in the *CloudFormation CLI User Guide for Extension Development* .

                                                                                      > The user registering the resource must be able to access the package in the S3 bucket. That's, the user must have [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) permissions for the schema handler package. For more information, see [Actions, Resources, and Condition Keys for Amazon S3](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazons3.html) in the *AWS Identity and Access Management User Guide* .

                                                                                      http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-hookversion.html#cfn-cloudformation-hookversion-schemahandlerpackage

                                                                                    property typeName

                                                                                    typeName: string;
                                                                                    • The unique name for your hook. Specifies a three-part namespace for your hook, with a recommended pattern of Organization::Service::Hook .

                                                                                      > The following organization namespaces are reserved and can't be used in your hook type names: > > - Alexa > - AMZN > - Amazon > - ASK > - AWS > - Custom > - Dev

                                                                                      http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-hookversion.html#cfn-cloudformation-hookversion-typename

                                                                                    method inspect

                                                                                    inspect: (inspector: cdk.TreeInspector) => void;
                                                                                    • Examines the CloudFormation resource and discloses attributes.

                                                                                      Parameter inspector

                                                                                      tree inspector to collect and process attributes

                                                                                    method renderProperties

                                                                                    protected renderProperties: (props: { [key: string]: any }) => {
                                                                                    [key: string]: any;
                                                                                    };

                                                                                      class CfnInclude

                                                                                      class CfnInclude extends CfnElement {}
                                                                                      • Includes a CloudFormation template into a stack. All elements of the template will be merged into the current stack, together with any elements created programmatically.

                                                                                        Deprecated

                                                                                        use the CfnInclude class from the cloudformation-include module instead

                                                                                      constructor

                                                                                      constructor(scope: Construct, id: string, props: CfnIncludeProps);
                                                                                      • Creates an adopted template construct. The template will be incorporated into the stack as-is with no changes at all. This means that logical IDs of entities within this template may conflict with logical IDs of entities that are part of the stack.

                                                                                        Parameter scope

                                                                                        The parent construct of this template

                                                                                        Parameter id

                                                                                        The ID of this construct

                                                                                        Parameter props

                                                                                        Initialization properties.

                                                                                      property template

                                                                                      readonly template: {};
                                                                                      • The included template.

                                                                                      class CfnJson

                                                                                      class CfnJson extends CoreConstruct implements IResolvable {}
                                                                                      • Captures a synthesis-time JSON object a CloudFormation reference which resolves during deployment to the resolved values of the JSON object.

                                                                                        The main use case for this is to overcome a limitation in CloudFormation that does not allow using intrinsic functions as dictionary keys (because dictionary keys in JSON must be strings). Specifically this is common in IAM conditions such as StringEquals: { lhs: "rhs" } where you want "lhs" to be a reference.

                                                                                        This object is resolvable, so it can be used as a value.

                                                                                        This construct is backed by a custom resource.

                                                                                      constructor

                                                                                      constructor(scope: Construct, id: string, props: CfnJsonProps);

                                                                                        property creationStack

                                                                                        readonly creationStack: string[];

                                                                                          property value

                                                                                          readonly value: Reference;
                                                                                          • An Fn::GetAtt to the JSON object passed through value and resolved during synthesis.

                                                                                            Normally there is no need to use this property since CfnJson is an IResolvable, so it can be simply used as a value.

                                                                                          method resolve

                                                                                          resolve: (_: IResolveContext) => any;

                                                                                            method toJSON

                                                                                            toJSON: () => string;
                                                                                            • This is required in case someone JSON.stringifys an object which refrences this object. Otherwise, we'll get a cyclic JSON reference.

                                                                                            class CfnMacro

                                                                                            class CfnMacro extends cdk.CfnResource implements cdk.IInspectable {}
                                                                                            • A CloudFormation AWS::CloudFormation::Macro

                                                                                              The AWS::CloudFormation::Macro resource is a CloudFormation resource type that creates a CloudFormation macro to perform custom processing on CloudFormation templates. For more information, see [Using AWS CloudFormation macros to perform custom processing on templates](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html) .

                                                                                              AWS::CloudFormation::Macro external

                                                                                              http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-macro.html

                                                                                            constructor

                                                                                            constructor(scope: cdk.Construct, id: string, props: cdk.CfnMacroProps);
                                                                                            • Create a new AWS::CloudFormation::Macro.

                                                                                              Parameter scope

                                                                                              scope in which this resource is defined

                                                                                              Parameter id

                                                                                              scoped id of the resource

                                                                                              Parameter props

                                                                                              resource properties

                                                                                            property CFN_RESOURCE_TYPE_NAME

                                                                                            static readonly CFN_RESOURCE_TYPE_NAME: string;
                                                                                            • The CloudFormation resource type name for this resource class.

                                                                                            property cfnProperties

                                                                                            readonly cfnProperties: { [key: string]: any };

                                                                                              property description

                                                                                              description: string;
                                                                                              • A description of the macro.

                                                                                                http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-macro.html#cfn-cloudformation-macro-description

                                                                                              property functionName

                                                                                              functionName: string;
                                                                                              • The Amazon Resource Name (ARN) of the underlying AWS Lambda function that you want AWS CloudFormation to invoke when the macro is run.

                                                                                                http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-macro.html#cfn-cloudformation-macro-functionname

                                                                                              property logGroupName

                                                                                              logGroupName: string;
                                                                                              • The CloudWatch Logs group to which AWS CloudFormation sends error logging information when invoking the macro's underlying AWS Lambda function.

                                                                                                http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-macro.html#cfn-cloudformation-macro-loggroupname

                                                                                              property logRoleArn

                                                                                              logRoleArn: string;
                                                                                              • The ARN of the role AWS CloudFormation should assume when sending log entries to CloudWatch Logs .

                                                                                                http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-macro.html#cfn-cloudformation-macro-logrolearn

                                                                                              property name

                                                                                              name: string;
                                                                                              • The name of the macro. The name of the macro must be unique across all macros in the account.

                                                                                                http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-macro.html#cfn-cloudformation-macro-name

                                                                                              method inspect

                                                                                              inspect: (inspector: cdk.TreeInspector) => void;
                                                                                              • Examines the CloudFormation resource and discloses attributes.

                                                                                                Parameter inspector

                                                                                                tree inspector to collect and process attributes

                                                                                              method renderProperties

                                                                                              protected renderProperties: (props: { [key: string]: any }) => {
                                                                                              [key: string]: any;
                                                                                              };

                                                                                                class CfnMapping

                                                                                                class CfnMapping extends CfnRefElement {}
                                                                                                • Represents a CloudFormation mapping.

                                                                                                constructor

                                                                                                constructor(scope: Construct, id: string, props?: CfnMappingProps);

                                                                                                  method findInMap

                                                                                                  findInMap: (key1: string, key2: string) => string;
                                                                                                  • Returns

                                                                                                    A reference to a value in the map based on the two keys.

                                                                                                  method setValue

                                                                                                  setValue: (key1: string, key2: string, value: any) => void;
                                                                                                  • Sets a value in the map based on the two keys.

                                                                                                  class CfnModuleDefaultVersion

                                                                                                  class CfnModuleDefaultVersion extends cdk.CfnResource implements cdk.IInspectable {}
                                                                                                  • A CloudFormation AWS::CloudFormation::ModuleDefaultVersion

                                                                                                    Specifies the default version of a module. The default version of the module will be used in CloudFormation operations for this account and Region.

                                                                                                    To register a module version, use the [AWS::CloudFormation::ModuleVersion](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-moduleversion.html) resource.

                                                                                                    For more information using modules, see [Using modules to encapsulate and reuse resource configurations](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/modules.html) and [Registering extensions](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry.html#registry-register) in the *CloudFormation User Guide* . For information on developing modules, see [Developing modules](https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/modules.html) in the *CloudFormation CLI User Guide* .

                                                                                                    AWS::CloudFormation::ModuleDefaultVersion external

                                                                                                    http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-moduledefaultversion.html

                                                                                                  constructor

                                                                                                  constructor(
                                                                                                  scope: cdk.Construct,
                                                                                                  id: string,
                                                                                                  props?: cdk.CfnModuleDefaultVersionProps
                                                                                                  );
                                                                                                  • Create a new AWS::CloudFormation::ModuleDefaultVersion.

                                                                                                    Parameter scope

                                                                                                    scope in which this resource is defined

                                                                                                    Parameter id

                                                                                                    scoped id of the resource

                                                                                                    Parameter props

                                                                                                    resource properties

                                                                                                  property arn

                                                                                                  arn: string;
                                                                                                  • The Amazon Resource Name (ARN) of the module version to set as the default version.

                                                                                                    Conditional: You must specify either Arn , or ModuleName and VersionId .

                                                                                                    http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-moduledefaultversion.html#cfn-cloudformation-moduledefaultversion-arn

                                                                                                  property CFN_RESOURCE_TYPE_NAME

                                                                                                  static readonly CFN_RESOURCE_TYPE_NAME: string;
                                                                                                  • The CloudFormation resource type name for this resource class.

                                                                                                  property cfnProperties

                                                                                                  readonly cfnProperties: { [key: string]: any };

                                                                                                    property moduleName

                                                                                                    moduleName: string;
                                                                                                    • The name of the module.

                                                                                                      Conditional: You must specify either Arn , or ModuleName and VersionId .

                                                                                                      http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-moduledefaultversion.html#cfn-cloudformation-moduledefaultversion-modulename

                                                                                                    property versionId

                                                                                                    versionId: string;
                                                                                                    • The ID for the specific version of the module.

                                                                                                      Conditional: You must specify either Arn , or ModuleName and VersionId .

                                                                                                      http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-moduledefaultversion.html#cfn-cloudformation-moduledefaultversion-versionid

                                                                                                    method inspect

                                                                                                    inspect: (inspector: cdk.TreeInspector) => void;
                                                                                                    • Examines the CloudFormation resource and discloses attributes.

                                                                                                      Parameter inspector

                                                                                                      tree inspector to collect and process attributes

                                                                                                    method renderProperties

                                                                                                    protected renderProperties: (props: { [key: string]: any }) => {
                                                                                                    [key: string]: any;
                                                                                                    };

                                                                                                      class CfnModuleVersion

                                                                                                      class CfnModuleVersion extends cdk.CfnResource implements cdk.IInspectable {}
                                                                                                      • A CloudFormation AWS::CloudFormation::ModuleVersion

                                                                                                        Registers the specified version of the module with the CloudFormation service. Registering a module makes it available for use in CloudFormation templates in your AWS account and Region.

                                                                                                        To specify a module version as the default version, use the [AWS::CloudFormation::ModuleDefaultVersion](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-moduledefaultversion.html) resource.

                                                                                                        For more information using modules, see [Using modules to encapsulate and reuse resource configurations](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/modules.html) and [Registering extensions](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry.html#registry-register) in the *CloudFormation User Guide* . For information on developing modules, see [Developing modules](https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/modules.html) in the *CloudFormation CLI User Guide* .

                                                                                                        AWS::CloudFormation::ModuleVersion external

                                                                                                        http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-moduleversion.html

                                                                                                      constructor

                                                                                                      constructor(scope: cdk.Construct, id: string, props: cdk.CfnModuleVersionProps);
                                                                                                      • Create a new AWS::CloudFormation::ModuleVersion.

                                                                                                        Parameter scope

                                                                                                        scope in which this resource is defined

                                                                                                        Parameter id

                                                                                                        scoped id of the resource

                                                                                                        Parameter props

                                                                                                        resource properties

                                                                                                      property attrArn

                                                                                                      readonly attrArn: string;
                                                                                                      • The Amazon Resource Name (ARN) of the module. Arn

                                                                                                      property attrDescription

                                                                                                      readonly attrDescription: string;
                                                                                                      • The description of the module. Description

                                                                                                      property attrDocumentationUrl

                                                                                                      readonly attrDocumentationUrl: string;
                                                                                                      • The URL of a page providing detailed documentation for this module. DocumentationUrl

                                                                                                      property attrIsDefaultVersion

                                                                                                      readonly attrIsDefaultVersion: cdk.IResolvable;
                                                                                                      • Whether the specified module version is set as the default version. IsDefaultVersion

                                                                                                      property attrSchema

                                                                                                      readonly attrSchema: string;
                                                                                                      • The schema that defines the module. Schema

                                                                                                      property attrTimeCreated

                                                                                                      readonly attrTimeCreated: string;
                                                                                                      • When the specified module version was registered. TimeCreated

                                                                                                      property attrVersionId

                                                                                                      readonly attrVersionId: string;
                                                                                                      • The ID of this version of the module. VersionId

                                                                                                      property attrVisibility

                                                                                                      readonly attrVisibility: string;
                                                                                                      • The scope at which the module is visible and usable in CloudFormation operations.

                                                                                                        Valid values include:

                                                                                                        - PRIVATE : The module is only visible and usable within the account in which it's registered. - PUBLIC : The module is publicly visible and usable within any Amazon account. Visibility

                                                                                                      property CFN_RESOURCE_TYPE_NAME

                                                                                                      static readonly CFN_RESOURCE_TYPE_NAME: string;
                                                                                                      • The CloudFormation resource type name for this resource class.

                                                                                                      property cfnProperties

                                                                                                      readonly cfnProperties: { [key: string]: any };

                                                                                                        property moduleName

                                                                                                        moduleName: string;
                                                                                                        • The name of the module being registered.

                                                                                                          http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-moduleversion.html#cfn-cloudformation-moduleversion-modulename

                                                                                                        property modulePackage

                                                                                                        modulePackage: string;
                                                                                                        • A URL to the S3 bucket containing the package that contains the template fragment and schema files for the module version to register.

                                                                                                          > The user registering the module version must be able to access the module package in the S3 bucket. That's, the user needs to have [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) permissions for the package. For more information, see [Actions, Resources, and Condition Keys for Amazon S3](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazons3.html) in the *AWS Identity and Access Management User Guide* .

                                                                                                          http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-moduleversion.html#cfn-cloudformation-moduleversion-modulepackage

                                                                                                        method inspect

                                                                                                        inspect: (inspector: cdk.TreeInspector) => void;
                                                                                                        • Examines the CloudFormation resource and discloses attributes.

                                                                                                          Parameter inspector

                                                                                                          tree inspector to collect and process attributes

                                                                                                        method renderProperties

                                                                                                        protected renderProperties: (props: { [key: string]: any }) => {
                                                                                                        [key: string]: any;
                                                                                                        };

                                                                                                          class CfnOutput

                                                                                                          class CfnOutput extends CfnElement {}

                                                                                                            constructor

                                                                                                            constructor(scope: Construct, id: string, props: CfnOutputProps);
                                                                                                            • Creates an CfnOutput value for this stack.

                                                                                                              Parameter scope

                                                                                                              The parent construct.

                                                                                                              Parameter props

                                                                                                              CfnOutput properties.

                                                                                                            property condition

                                                                                                            condition: CfnCondition;
                                                                                                            • A condition to associate with this output value. If the condition evaluates to false, this output value will not be included in the stack.

                                                                                                              - No condition is associated with the output.

                                                                                                            property description

                                                                                                            description: string;
                                                                                                            • A String type that describes the output value. The description can be a maximum of 4 K in length.

                                                                                                              - No description.

                                                                                                            property exportName

                                                                                                            exportName: string;
                                                                                                            • The name used to export the value of this output across stacks.

                                                                                                              To use the value in another stack, pass the value of output.importValue to it.

                                                                                                              - the output is not exported

                                                                                                            property importValue

                                                                                                            readonly importValue: string;
                                                                                                            • Return the Fn.importValue expression to import this value into another stack

                                                                                                              The returned value should not be used in the same stack, but in a different one. It must be deployed to the same environment, as CloudFormation exports can only be imported in the same Region and account.

                                                                                                              The is no automatic registration of dependencies between stacks when using this mechanism, so you should make sure to deploy them in the right order yourself.

                                                                                                              You can use this mechanism to share values across Stacks in different Stages. If you intend to share the value to another Stack inside the same Stage, the automatic cross-stack referencing mechanism is more convenient.

                                                                                                            property value

                                                                                                            value: any;
                                                                                                            • The value of the property returned by the aws cloudformation describe-stacks command. The value of an output can include literals, parameter references, pseudo-parameters, a mapping value, or intrinsic functions.

                                                                                                            method validate

                                                                                                            protected validate: () => string[];

                                                                                                              class CfnParameter

                                                                                                              class CfnParameter extends CfnElement {}
                                                                                                              • A CloudFormation parameter.

                                                                                                                Use the optional Parameters section to customize your templates. Parameters enable you to input custom values to your template each time you create or update a stack.

                                                                                                              constructor

                                                                                                              constructor(scope: Construct, id: string, props?: CfnParameterProps);
                                                                                                              • Creates a parameter construct. Note that the name (logical ID) of the parameter will derive from it's coname and location within the stack. Therefore, it is recommended that parameters are defined at the stack level.

                                                                                                                Parameter scope

                                                                                                                The parent construct.

                                                                                                                Parameter props

                                                                                                                The parameter properties.

                                                                                                              property allowedPattern

                                                                                                              allowedPattern: string;
                                                                                                              • A regular expression that represents the patterns to allow for String types.

                                                                                                                - No constraints on patterns allowed for parameter.

                                                                                                              property allowedValues

                                                                                                              allowedValues: string[];
                                                                                                              • An array containing the list of values allowed for the parameter.

                                                                                                                - No constraints on values allowed for parameter.

                                                                                                              property constraintDescription

                                                                                                              constraintDescription: string;
                                                                                                              • A string that explains a constraint when the constraint is violated. For example, without a constraint description, a parameter that has an allowed pattern of [A-Za-z0-9]+ displays the following error message when the user specifies an invalid value:

                                                                                                                - No description with customized error message when user specifies invalid values.

                                                                                                              property default

                                                                                                              default: any;
                                                                                                              • A value of the appropriate type for the template to use if no value is specified when a stack is created. If you define constraints for the parameter, you must specify a value that adheres to those constraints.

                                                                                                                - No default value for parameter.

                                                                                                              property description

                                                                                                              description: string;
                                                                                                              • A string of up to 4000 characters that describes the parameter.

                                                                                                                - No description for the parameter.

                                                                                                              property maxLength

                                                                                                              maxLength: number;
                                                                                                              • An integer value that determines the largest number of characters you want to allow for String types.

                                                                                                                - None.

                                                                                                              property maxValue

                                                                                                              maxValue: number;
                                                                                                              • A numeric value that determines the largest numeric value you want to allow for Number types.

                                                                                                                - None.

                                                                                                              property minLength

                                                                                                              minLength: number;
                                                                                                              • An integer value that determines the smallest number of characters you want to allow for String types.

                                                                                                                - None.

                                                                                                              property minValue

                                                                                                              minValue: number;
                                                                                                              • A numeric value that determines the smallest numeric value you want to allow for Number types.

                                                                                                                - None.

                                                                                                              property noEcho

                                                                                                              noEcho: boolean;
                                                                                                              • Indicates if this parameter is configured with "NoEcho" enabled.

                                                                                                              property type

                                                                                                              type: string;
                                                                                                              • The data type for the parameter (DataType).

                                                                                                                String

                                                                                                              property value

                                                                                                              readonly value: IResolvable;
                                                                                                              • The parameter value as a Token

                                                                                                              property valueAsList

                                                                                                              readonly valueAsList: string[];
                                                                                                              • The parameter value, if it represents a string list.

                                                                                                              property valueAsNumber

                                                                                                              readonly valueAsNumber: number;
                                                                                                              • The parameter value, if it represents a number.

                                                                                                              property valueAsString

                                                                                                              readonly valueAsString: string;
                                                                                                              • The parameter value, if it represents a string.

                                                                                                              method resolve

                                                                                                              resolve: (_context: IResolveContext) => any;

                                                                                                                class CfnPublicTypeVersion

                                                                                                                class CfnPublicTypeVersion extends cdk.CfnResource implements cdk.IInspectable {}
                                                                                                                • A CloudFormation AWS::CloudFormation::PublicTypeVersion

                                                                                                                  Tests and publishes a registered extension as a public, third-party extension.

                                                                                                                  CloudFormation first tests the extension to make sure it meets all necessary requirements for being published in the CloudFormation registry. If it does, CloudFormation then publishes it to the registry as a public third-party extension in this Region. Public extensions are available for use by all CloudFormation users.

                                                                                                                  - For resource types, testing includes passing all contracts tests defined for the type. - For modules, testing includes determining if the module's model meets all necessary requirements.

                                                                                                                  For more information, see [Testing your public extension prior to publishing](https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/publish-extension.html#publish-extension-testing) in the *CloudFormation CLI User Guide* .

                                                                                                                  If you don't specify a version, CloudFormation uses the default version of the extension in your account and Region for testing.

                                                                                                                  To perform testing, CloudFormation assumes the execution role specified when the type was registered.

                                                                                                                  An extension must have a test status of PASSED before it can be published. For more information, see [Publishing extensions to make them available for public use](https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-type-publish.html) in the *CloudFormation CLI User Guide* .

                                                                                                                  AWS::CloudFormation::PublicTypeVersion external

                                                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-publictypeversion.html

                                                                                                                constructor

                                                                                                                constructor(
                                                                                                                scope: cdk.Construct,
                                                                                                                id: string,
                                                                                                                props?: cdk.CfnPublicTypeVersionProps
                                                                                                                );
                                                                                                                • Create a new AWS::CloudFormation::PublicTypeVersion.

                                                                                                                  Parameter scope

                                                                                                                  scope in which this resource is defined

                                                                                                                  Parameter id

                                                                                                                  scoped id of the resource

                                                                                                                  Parameter props

                                                                                                                  resource properties

                                                                                                                property arn

                                                                                                                arn: string;
                                                                                                                • The Amazon Resource Number (ARN) of the extension.

                                                                                                                  Conditional: You must specify Arn , or TypeName and Type .

                                                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-publictypeversion.html#cfn-cloudformation-publictypeversion-arn

                                                                                                                property attrPublicTypeArn

                                                                                                                readonly attrPublicTypeArn: string;
                                                                                                                • The Amazon Resource Number (ARN) assigned to the public extension upon publication. PublicTypeArn

                                                                                                                property attrPublisherId

                                                                                                                readonly attrPublisherId: string;
                                                                                                                • The publisher ID of the extension publisher. PublisherId

                                                                                                                property attrTypeVersionArn

                                                                                                                readonly attrTypeVersionArn: string;
                                                                                                                • The Amazon Resource Number (ARN) assigned to this version of the extension. TypeVersionArn

                                                                                                                property CFN_RESOURCE_TYPE_NAME

                                                                                                                static readonly CFN_RESOURCE_TYPE_NAME: string;
                                                                                                                • The CloudFormation resource type name for this resource class.

                                                                                                                property cfnProperties

                                                                                                                readonly cfnProperties: { [key: string]: any };

                                                                                                                  property logDeliveryBucket

                                                                                                                  logDeliveryBucket: string;
                                                                                                                  • The S3 bucket to which CloudFormation delivers the contract test execution logs.

                                                                                                                    CloudFormation delivers the logs by the time contract testing has completed and the extension has been assigned a test type status of PASSED or FAILED .

                                                                                                                    The user initiating the stack operation must be able to access items in the specified S3 bucket. Specifically, the user needs the following permissions:

                                                                                                                    - GetObject - PutObject

                                                                                                                    For more information, see [Actions, Resources, and Condition Keys for Amazon S3](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazons3.html) in the *AWS Identity and Access Management User Guide* .

                                                                                                                    http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-publictypeversion.html#cfn-cloudformation-publictypeversion-logdeliverybucket

                                                                                                                  property publicVersionNumber

                                                                                                                  publicVersionNumber: string;
                                                                                                                  • The version number to assign to this version of the extension.

                                                                                                                    Use the following format, and adhere to semantic versioning when assigning a version number to your extension:

                                                                                                                    MAJOR.MINOR.PATCH

                                                                                                                    For more information, see [Semantic Versioning 2.0.0](https://docs.aws.amazon.com/https://semver.org/) .

                                                                                                                    If you don't specify a version number, CloudFormation increments the version number by one minor version release.

                                                                                                                    You cannot specify a version number the first time you publish a type. AWS CloudFormation automatically sets the first version number to be 1.0.0 .

                                                                                                                    http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-publictypeversion.html#cfn-cloudformation-publictypeversion-publicversionnumber

                                                                                                                  property type

                                                                                                                  type: string;
                                                                                                                  • The type of the extension to test.

                                                                                                                    Conditional: You must specify Arn , or TypeName and Type .

                                                                                                                    http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-publictypeversion.html#cfn-cloudformation-publictypeversion-type

                                                                                                                  property typeName

                                                                                                                  typeName: string;
                                                                                                                  • The name of the extension to test.

                                                                                                                    Conditional: You must specify Arn , or TypeName and Type .

                                                                                                                    http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-publictypeversion.html#cfn-cloudformation-publictypeversion-typename

                                                                                                                  method inspect

                                                                                                                  inspect: (inspector: cdk.TreeInspector) => void;
                                                                                                                  • Examines the CloudFormation resource and discloses attributes.

                                                                                                                    Parameter inspector

                                                                                                                    tree inspector to collect and process attributes

                                                                                                                  method renderProperties

                                                                                                                  protected renderProperties: (props: { [key: string]: any }) => {
                                                                                                                  [key: string]: any;
                                                                                                                  };

                                                                                                                    class CfnPublisher

                                                                                                                    class CfnPublisher extends cdk.CfnResource implements cdk.IInspectable {}
                                                                                                                    • A CloudFormation AWS::CloudFormation::Publisher

                                                                                                                      Registers your account as a publisher of public extensions in the CloudFormation registry. Public extensions are available for use by all CloudFormation users.

                                                                                                                      For information on requirements for registering as a public extension publisher, see [Registering your account to publish CloudFormation extensions](https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/publish-extension.html#publish-extension-prereqs) in the *CloudFormation CLI User Guide* .

                                                                                                                      AWS::CloudFormation::Publisher external

                                                                                                                      http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-publisher.html

                                                                                                                    constructor

                                                                                                                    constructor(scope: cdk.Construct, id: string, props: cdk.CfnPublisherProps);
                                                                                                                    • Create a new AWS::CloudFormation::Publisher.

                                                                                                                      Parameter scope

                                                                                                                      scope in which this resource is defined

                                                                                                                      Parameter id

                                                                                                                      scoped id of the resource

                                                                                                                      Parameter props

                                                                                                                      resource properties

                                                                                                                    property acceptTermsAndConditions

                                                                                                                    acceptTermsAndConditions: boolean | cdk.IResolvable;
                                                                                                                    • Whether you accept the [Terms and Conditions](https://docs.aws.amazon.com/https://cloudformation-registry-documents.s3.amazonaws.com/Terms_and_Conditions_for_AWS_CloudFormation_Registry_Publishers.pdf) for publishing extensions in the CloudFormation registry. You must accept the terms and conditions in order to register to publish public extensions to the CloudFormation registry.

                                                                                                                      The default is false .

                                                                                                                      http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-publisher.html#cfn-cloudformation-publisher-accepttermsandconditions

                                                                                                                    property attrIdentityProvider

                                                                                                                    readonly attrIdentityProvider: string;
                                                                                                                    • The type of account used as the identity provider when registering this publisher with CloudFormation .

                                                                                                                      Values include: AWS_Marketplace | Bitbucket | GitHub . IdentityProvider

                                                                                                                    property attrPublisherId

                                                                                                                    readonly attrPublisherId: string;
                                                                                                                    • The ID of the extension publisher. This publisher ID applies to your account in all AWS Regions . PublisherId

                                                                                                                    property attrPublisherProfile

                                                                                                                    readonly attrPublisherProfile: string;
                                                                                                                    • The URL to the publisher's profile with the identity provider. PublisherProfile

                                                                                                                    property attrPublisherStatus

                                                                                                                    readonly attrPublisherStatus: string;
                                                                                                                    • Whether the publisher is verified. PublisherStatus

                                                                                                                    property CFN_RESOURCE_TYPE_NAME

                                                                                                                    static readonly CFN_RESOURCE_TYPE_NAME: string;
                                                                                                                    • The CloudFormation resource type name for this resource class.

                                                                                                                    property cfnProperties

                                                                                                                    readonly cfnProperties: { [key: string]: any };

                                                                                                                      property connectionArn

                                                                                                                      connectionArn: string;
                                                                                                                      • If you are using a Bitbucket or GitHub account for identity verification, the Amazon Resource Name (ARN) for your connection to that account.

                                                                                                                        For more information, see [Registering your account to publish CloudFormation extensions](https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/publish-extension.html#publish-extension-prereqs) in the *CloudFormation CLI User Guide* .

                                                                                                                        http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-publisher.html#cfn-cloudformation-publisher-connectionarn

                                                                                                                      method inspect

                                                                                                                      inspect: (inspector: cdk.TreeInspector) => void;
                                                                                                                      • Examines the CloudFormation resource and discloses attributes.

                                                                                                                        Parameter inspector

                                                                                                                        tree inspector to collect and process attributes

                                                                                                                      method renderProperties

                                                                                                                      protected renderProperties: (props: { [key: string]: any }) => {
                                                                                                                      [key: string]: any;
                                                                                                                      };

                                                                                                                        class CfnRefElement

                                                                                                                        abstract class CfnRefElement extends CfnElement {}
                                                                                                                        • Base class for referenceable CloudFormation constructs which are not Resources

                                                                                                                          These constructs are things like Conditions and Parameters, can be referenced by taking the .ref attribute.

                                                                                                                          Resource constructs do not inherit from CfnRefElement because they have their own, more specific types returned from the .ref attribute. Also, some resources aren't referenceable at all (such as BucketPolicies or GatewayAttachments).

                                                                                                                        property ref

                                                                                                                        readonly ref: string;
                                                                                                                        • Return a string that will be resolved to a CloudFormation { Ref } for this element.

                                                                                                                          If, by any chance, the intrinsic reference of a resource is not a string, you could coerce it to an IResolvable through Lazy.any({ produce: resource.ref }).

                                                                                                                        class CfnResource

                                                                                                                        class CfnResource extends CfnRefElement {}
                                                                                                                        • Represents a CloudFormation resource.

                                                                                                                        constructor

                                                                                                                        constructor(scope: Construct, id: string, props: CfnResourceProps);
                                                                                                                        • Creates a resource construct.

                                                                                                                          Parameter cfnResourceType

                                                                                                                          The CloudFormation type of this resource (e.g. AWS::DynamoDB::Table)

                                                                                                                        property cfnOptions

                                                                                                                        readonly cfnOptions: ICfnResourceOptions;
                                                                                                                        • Options for this resource, such as condition, update policy etc.

                                                                                                                        property cfnProperties

                                                                                                                        readonly cfnProperties: { [key: string]: any };

                                                                                                                          property cfnResourceType

                                                                                                                          readonly cfnResourceType: string;
                                                                                                                          • AWS resource type.

                                                                                                                          property updatedProperites

                                                                                                                          readonly updatedProperites: { [key: string]: any };
                                                                                                                          • Return properties modified after initiation

                                                                                                                            Resources that expose mutable properties should override this function to collect and return the properties object for this resource.

                                                                                                                          method addDeletionOverride

                                                                                                                          addDeletionOverride: (path: string) => void;
                                                                                                                          • Syntactic sugar for addOverride(path, undefined).

                                                                                                                            Parameter path

                                                                                                                            The path of the value to delete

                                                                                                                          method addDependsOn

                                                                                                                          addDependsOn: (target: CfnResource) => void;
                                                                                                                          • Indicates that this resource depends on another resource and cannot be provisioned unless the other resource has been successfully provisioned.

                                                                                                                            This can be used for resources across stacks (or nested stack) boundaries and the dependency will automatically be transferred to the relevant scope.

                                                                                                                          method addMetadata

                                                                                                                          addMetadata: (key: string, value: any) => void;
                                                                                                                          • Add a value to the CloudFormation Resource Metadata

                                                                                                                            See Also

                                                                                                                            • https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html

                                                                                                                              Note that this is a different set of metadata from CDK node metadata; this metadata ends up in the stack template under the resource, whereas CDK node metadata ends up in the Cloud Assembly.

                                                                                                                          method addOverride

                                                                                                                          addOverride: (path: string, value: any) => void;
                                                                                                                          • Adds an override to the synthesized CloudFormation resource. To add a property override, either use addPropertyOverride or prefix path with "Properties." (i.e. Properties.TopicName).

                                                                                                                            If the override is nested, separate each nested level using a dot (.) in the path parameter. If there is an array as part of the nesting, specify the index in the path.

                                                                                                                            To include a literal . in the property name, prefix with a \. In most programming languages you will need to write this as "\\." because the \ itself will need to be escaped.

                                                                                                                            For example,

                                                                                                                            cfnResource.addOverride('Properties.GlobalSecondaryIndexes.0.Projection.NonKeyAttributes', ['myattribute']);
                                                                                                                            cfnResource.addOverride('Properties.GlobalSecondaryIndexes.1.ProjectionType', 'INCLUDE');

                                                                                                                            would add the overrides

                                                                                                                            "Properties": {
                                                                                                                            "GlobalSecondaryIndexes": [
                                                                                                                            {
                                                                                                                            "Projection": {
                                                                                                                            "NonKeyAttributes": [ "myattribute" ]
                                                                                                                            ...
                                                                                                                            }
                                                                                                                            ...
                                                                                                                            },
                                                                                                                            {
                                                                                                                            "ProjectionType": "INCLUDE"
                                                                                                                            ...
                                                                                                                            },
                                                                                                                            ]
                                                                                                                            ...
                                                                                                                            }

                                                                                                                            The value argument to addOverride will not be processed or translated in any way. Pass raw JSON values in here with the correct capitalization for CloudFormation. If you pass CDK classes or structs, they will be rendered with lowercased key names, and CloudFormation will reject the template.

                                                                                                                            Parameter path

                                                                                                                            The path of the property, you can use dot notation to override values in complex types. Any intermdediate keys will be created as needed.

                                                                                                                            Parameter value

                                                                                                                            The value. Could be primitive or complex.

                                                                                                                          method addPropertyDeletionOverride

                                                                                                                          addPropertyDeletionOverride: (propertyPath: string) => void;
                                                                                                                          • Adds an override that deletes the value of a property from the resource definition.

                                                                                                                            Parameter propertyPath

                                                                                                                            The path to the property.

                                                                                                                          method addPropertyOverride

                                                                                                                          addPropertyOverride: (propertyPath: string, value: any) => void;
                                                                                                                          • Adds an override to a resource property.

                                                                                                                            Syntactic sugar for addOverride("Properties.<...>", value).

                                                                                                                            Parameter propertyPath

                                                                                                                            The path of the property

                                                                                                                            Parameter value

                                                                                                                            The value

                                                                                                                          method applyRemovalPolicy

                                                                                                                          applyRemovalPolicy: (
                                                                                                                          policy: RemovalPolicy | undefined,
                                                                                                                          options?: RemovalPolicyOptions
                                                                                                                          ) => void;
                                                                                                                          • Sets the deletion policy of the resource based on the removal policy specified.

                                                                                                                            The Removal Policy controls what happens to this resource when it stops being managed by CloudFormation, either because you've removed it from the CDK application or because you've made a change that requires the resource to be replaced.

                                                                                                                            The resource can be deleted (RemovalPolicy.DESTROY), or left in your AWS account for data recovery and cleanup later (RemovalPolicy.RETAIN).

                                                                                                                          method getAtt

                                                                                                                          getAtt: (attributeName: string) => Reference;
                                                                                                                          • Returns a token for an runtime attribute of this resource. Ideally, use generated attribute accessors (e.g. resource.arn), but this can be used for future compatibility in case there is no generated attribute.

                                                                                                                            Parameter attributeName

                                                                                                                            The name of the attribute.

                                                                                                                          method getMetadata

                                                                                                                          getMetadata: (key: string) => any;
                                                                                                                          • Retrieve a value value from the CloudFormation Resource Metadata

                                                                                                                            See Also

                                                                                                                            • https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html

                                                                                                                              Note that this is a different set of metadata from CDK node metadata; this metadata ends up in the stack template under the resource, whereas CDK node metadata ends up in the Cloud Assembly.

                                                                                                                          method isCfnResource

                                                                                                                          static isCfnResource: (construct: IConstruct) => construct is CfnResource;
                                                                                                                          • Check whether the given construct is a CfnResource

                                                                                                                          method renderProperties

                                                                                                                          protected renderProperties: (props: { [key: string]: any }) => {
                                                                                                                          [key: string]: any;
                                                                                                                          };

                                                                                                                            method shouldSynthesize

                                                                                                                            protected shouldSynthesize: () => boolean;
                                                                                                                            • Can be overridden by subclasses to determine if this resource will be rendered into the cloudformation template.

                                                                                                                              Returns

                                                                                                                              true if the resource should be included or false is the resource should be omitted.

                                                                                                                            method toString

                                                                                                                            toString: () => string;
                                                                                                                            • Returns

                                                                                                                              a string representation of this resource

                                                                                                                            method validateProperties

                                                                                                                            protected validateProperties: (_properties: any) => void;

                                                                                                                              class CfnResourceDefaultVersion

                                                                                                                              class CfnResourceDefaultVersion
                                                                                                                              extends cdk.CfnResource
                                                                                                                              implements cdk.IInspectable {}
                                                                                                                              • A CloudFormation AWS::CloudFormation::ResourceDefaultVersion

                                                                                                                                Specifies the default version of a resource. The default version of a resource will be used in CloudFormation operations.

                                                                                                                                AWS::CloudFormation::ResourceDefaultVersion external

                                                                                                                                http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-resourcedefaultversion.html

                                                                                                                              constructor

                                                                                                                              constructor(
                                                                                                                              scope: cdk.Construct,
                                                                                                                              id: string,
                                                                                                                              props?: cdk.CfnResourceDefaultVersionProps
                                                                                                                              );
                                                                                                                              • Create a new AWS::CloudFormation::ResourceDefaultVersion.

                                                                                                                                Parameter scope

                                                                                                                                scope in which this resource is defined

                                                                                                                                Parameter id

                                                                                                                                scoped id of the resource

                                                                                                                                Parameter props

                                                                                                                                resource properties

                                                                                                                              property attrArn

                                                                                                                              readonly attrArn: string;
                                                                                                                              • The Amazon Resource Name (ARN) of the resource. Arn

                                                                                                                              property CFN_RESOURCE_TYPE_NAME

                                                                                                                              static readonly CFN_RESOURCE_TYPE_NAME: string;
                                                                                                                              • The CloudFormation resource type name for this resource class.

                                                                                                                              property cfnProperties

                                                                                                                              readonly cfnProperties: { [key: string]: any };

                                                                                                                                property typeName

                                                                                                                                typeName: string;
                                                                                                                                • The name of the resource.

                                                                                                                                  Conditional: You must specify either TypeVersionArn , or TypeName and VersionId .

                                                                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-resourcedefaultversion.html#cfn-cloudformation-resourcedefaultversion-typename

                                                                                                                                property typeVersionArn

                                                                                                                                typeVersionArn: string;
                                                                                                                                • The Amazon Resource Name (ARN) of the resource version.

                                                                                                                                  Conditional: You must specify either TypeVersionArn , or TypeName and VersionId .

                                                                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-resourcedefaultversion.html#cfn-cloudformation-resourcedefaultversion-typeversionarn

                                                                                                                                property versionId

                                                                                                                                versionId: string;
                                                                                                                                • The ID of a specific version of the resource. The version ID is the value at the end of the Amazon Resource Name (ARN) assigned to the resource version when it's registered.

                                                                                                                                  Conditional: You must specify either TypeVersionArn , or TypeName and VersionId .

                                                                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-resourcedefaultversion.html#cfn-cloudformation-resourcedefaultversion-versionid

                                                                                                                                method inspect

                                                                                                                                inspect: (inspector: cdk.TreeInspector) => void;
                                                                                                                                • Examines the CloudFormation resource and discloses attributes.

                                                                                                                                  Parameter inspector

                                                                                                                                  tree inspector to collect and process attributes

                                                                                                                                method renderProperties

                                                                                                                                protected renderProperties: (props: { [key: string]: any }) => {
                                                                                                                                [key: string]: any;
                                                                                                                                };

                                                                                                                                  class CfnResourceVersion

                                                                                                                                  class CfnResourceVersion extends cdk.CfnResource implements cdk.IInspectable {}
                                                                                                                                  • A CloudFormation AWS::CloudFormation::ResourceVersion

                                                                                                                                    Registers a resource version with the CloudFormation service. Registering a resource version makes it available for use in CloudFormation templates in your AWS account , and includes:

                                                                                                                                    - Validating the resource schema. - Determining which handlers, if any, have been specified for the resource. - Making the resource available for use in your account.

                                                                                                                                    For more information on how to develop resources and ready them for registration, see [Creating Resource Providers](https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-types.html) in the *CloudFormation CLI User Guide* .

                                                                                                                                    You can have a maximum of 50 resource versions registered at a time. This maximum is per account and per Region.

                                                                                                                                    AWS::CloudFormation::ResourceVersion external

                                                                                                                                    http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-resourceversion.html

                                                                                                                                  constructor

                                                                                                                                  constructor(
                                                                                                                                  scope: cdk.Construct,
                                                                                                                                  id: string,
                                                                                                                                  props: cdk.CfnResourceVersionProps
                                                                                                                                  );
                                                                                                                                  • Create a new AWS::CloudFormation::ResourceVersion.

                                                                                                                                    Parameter scope

                                                                                                                                    scope in which this resource is defined

                                                                                                                                    Parameter id

                                                                                                                                    scoped id of the resource

                                                                                                                                    Parameter props

                                                                                                                                    resource properties

                                                                                                                                  property attrArn

                                                                                                                                  readonly attrArn: string;
                                                                                                                                  • The Amazon Resource Name (ARN) of the resource version. Arn

                                                                                                                                  property attrIsDefaultVersion

                                                                                                                                  readonly attrIsDefaultVersion: cdk.IResolvable;
                                                                                                                                  • Whether the resource version is set as the default version. IsDefaultVersion

                                                                                                                                  property attrProvisioningType

                                                                                                                                  readonly attrProvisioningType: string;
                                                                                                                                  • The provisioning behavior of the resource type. CloudFormation determines the provisioning type during registration, based on the types of handlers in the schema handler package submitted.

                                                                                                                                    Valid values include:

                                                                                                                                    - FULLY_MUTABLE : The resource type includes an update handler to process updates to the type during stack update operations. - IMMUTABLE : The resource type doesn't include an update handler, so the type can't be updated and must instead be replaced during stack update operations. - NON_PROVISIONABLE : The resource type doesn't include all the following handlers, and therefore can't actually be provisioned.

                                                                                                                                    - create - read - delete ProvisioningType

                                                                                                                                  property attrTypeArn

                                                                                                                                  readonly attrTypeArn: string;
                                                                                                                                  • The Amazon Resource Name (ARN) of the resource. TypeArn

                                                                                                                                  property attrVersionId

                                                                                                                                  readonly attrVersionId: string;
                                                                                                                                  • The ID of a specific version of the resource. The version ID is the value at the end of the Amazon Resource Name (ARN) assigned to the resource version when it is registered. VersionId

                                                                                                                                  property attrVisibility

                                                                                                                                  readonly attrVisibility: string;
                                                                                                                                  • The scope at which the resource is visible and usable in CloudFormation operations.

                                                                                                                                    Valid values include:

                                                                                                                                    - PRIVATE : The resource is only visible and usable within the account in which it's registered. CloudFormation marks any resources you register as PRIVATE . - PUBLIC : The resource is publicly visible and usable within any Amazon account. Visibility

                                                                                                                                  property CFN_RESOURCE_TYPE_NAME

                                                                                                                                  static readonly CFN_RESOURCE_TYPE_NAME: string;
                                                                                                                                  • The CloudFormation resource type name for this resource class.

                                                                                                                                  property cfnProperties

                                                                                                                                  readonly cfnProperties: { [key: string]: any };

                                                                                                                                    property executionRoleArn

                                                                                                                                    executionRoleArn: string;
                                                                                                                                    • The Amazon Resource Name (ARN) of the IAM role for CloudFormation to assume when invoking the resource. If your resource calls AWS APIs in any of its handlers, you must create an *[IAM execution role](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)* that includes the necessary permissions to call those AWS APIs, and provision that execution role in your account. When CloudFormation needs to invoke the resource type handler, CloudFormation assumes this execution role to create a temporary session token, which it then passes to the resource type handler, thereby supplying your resource type with the appropriate credentials.

                                                                                                                                      http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-resourceversion.html#cfn-cloudformation-resourceversion-executionrolearn

                                                                                                                                    property loggingConfig

                                                                                                                                    loggingConfig: cdk.IResolvable | cdk.CfnResourceVersion.LoggingConfigProperty;
                                                                                                                                    • Logging configuration information for a resource.

                                                                                                                                      http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-resourceversion.html#cfn-cloudformation-resourceversion-loggingconfig

                                                                                                                                    property schemaHandlerPackage

                                                                                                                                    schemaHandlerPackage: string;
                                                                                                                                    • A URL to the S3 bucket containing the resource project package that contains the necessary files for the resource you want to register.

                                                                                                                                      For information on generating a schema handler package for the resource you want to register, see [submit](https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-type-cli-submit.html) in the *CloudFormation CLI User Guide* .

                                                                                                                                      > The user registering the resource must be able to access the package in the S3 bucket. That is, the user needs to have [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) permissions for the schema handler package. For more information, see [Actions, Resources, and Condition Keys for Amazon S3](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazons3.html) in the *AWS Identity and Access Management User Guide* .

                                                                                                                                      http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-resourceversion.html#cfn-cloudformation-resourceversion-schemahandlerpackage

                                                                                                                                    property typeName

                                                                                                                                    typeName: string;
                                                                                                                                    • The name of the resource being registered.

                                                                                                                                      We recommend that resource names adhere to the following pattern: *company_or_organization* :: *service* :: *type* .

                                                                                                                                      > The following organization namespaces are reserved and can't be used in your resource names: > > - Alexa > - AMZN > - Amazon > - AWS > - Custom > - Dev

                                                                                                                                      http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-resourceversion.html#cfn-cloudformation-resourceversion-typename

                                                                                                                                    method inspect

                                                                                                                                    inspect: (inspector: cdk.TreeInspector) => void;
                                                                                                                                    • Examines the CloudFormation resource and discloses attributes.

                                                                                                                                      Parameter inspector

                                                                                                                                      tree inspector to collect and process attributes

                                                                                                                                    method renderProperties

                                                                                                                                    protected renderProperties: (props: { [key: string]: any }) => {
                                                                                                                                    [key: string]: any;
                                                                                                                                    };

                                                                                                                                      class CfnRule

                                                                                                                                      class CfnRule extends CfnRefElement {}
                                                                                                                                      • The Rules that define template constraints in an AWS Service Catalog portfolio describe when end users can use the template and which values they can specify for parameters that are declared in the AWS CloudFormation template used to create the product they are attempting to use. Rules are useful for preventing end users from inadvertently specifying an incorrect value. For example, you can add a rule to verify whether end users specified a valid subnet in a given VPC or used m1.small instance types for test environments. AWS CloudFormation uses rules to validate parameter values before it creates the resources for the product.

                                                                                                                                        A rule can include a RuleCondition property and must include an Assertions property. For each rule, you can define only one rule condition; you can define one or more asserts within the Assertions property. You define a rule condition and assertions by using rule-specific intrinsic functions.

                                                                                                                                        https://docs.aws.amazon.com/servicecatalog/latest/adminguide/reference-template_constraint_rules.html

                                                                                                                                      constructor

                                                                                                                                      constructor(scope: Construct, id: string, props?: CfnRuleProps);
                                                                                                                                      • Creates and adds a rule.

                                                                                                                                        Parameter scope

                                                                                                                                        The parent construct.

                                                                                                                                        Parameter props

                                                                                                                                        The rule props.

                                                                                                                                      method addAssertion

                                                                                                                                      addAssertion: (condition: ICfnConditionExpression, description: string) => void;
                                                                                                                                      • Adds an assertion to the rule.

                                                                                                                                        Parameter condition

                                                                                                                                        The expression to evaluation.

                                                                                                                                        Parameter description

                                                                                                                                        The description of the assertion.

                                                                                                                                      class CfnStack

                                                                                                                                      class CfnStack extends cdk.CfnResource implements cdk.IInspectable {}
                                                                                                                                      • A CloudFormation AWS::CloudFormation::Stack

                                                                                                                                        The AWS::CloudFormation::Stack resource nests a stack as a resource in a top-level template.

                                                                                                                                        You can add output values from a nested stack within the containing template. You use the [GetAtt](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-getatt.html) function with the nested stack's logical name and the name of the output value in the nested stack in the format Outputs. *NestedStackOutputName* .

                                                                                                                                        > We strongly recommend that updates to nested stacks are run from the parent stack.

                                                                                                                                        When you apply template changes to update a top-level stack, CloudFormation updates the top-level stack and initiates an update to its nested stacks. CloudFormation updates the resources of modified nested stacks, but doesn't update the resources of unmodified nested stacks. For more information, see [CloudFormation stack updates](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks.html) .

                                                                                                                                        > You must acknowledge IAM capabilities for nested stacks that contain IAM resources. Also, verify that you have cancel update stack permissions, which is required if an update rolls back. For more information about IAM and CloudFormation , see [Controlling access with AWS Identity and Access Management](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) .

                                                                                                                                        AWS::CloudFormation::Stack external

                                                                                                                                        http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-stack.html

                                                                                                                                      constructor

                                                                                                                                      constructor(scope: cdk.Construct, id: string, props: cdk.CfnStackProps);
                                                                                                                                      • Create a new AWS::CloudFormation::Stack.

                                                                                                                                        Parameter scope

                                                                                                                                        scope in which this resource is defined

                                                                                                                                        Parameter id

                                                                                                                                        scoped id of the resource

                                                                                                                                        Parameter props

                                                                                                                                        resource properties

                                                                                                                                      property CFN_RESOURCE_TYPE_NAME

                                                                                                                                      static readonly CFN_RESOURCE_TYPE_NAME: string;
                                                                                                                                      • The CloudFormation resource type name for this resource class.

                                                                                                                                      property cfnProperties

                                                                                                                                      readonly cfnProperties: { [key: string]: any };

                                                                                                                                        property notificationArns

                                                                                                                                        notificationArns: string[];
                                                                                                                                        • The Amazon Simple Notification Service (Amazon SNS) topic ARNs to publish stack related events. You can find your Amazon SNS topic ARNs using the Amazon SNS console or your Command Line Interface (CLI).

                                                                                                                                          http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-stack.html#cfn-cloudformation-stack-notificationarns

                                                                                                                                        property parameters

                                                                                                                                        parameters: cdk.IResolvable | { [key: string]: string };
                                                                                                                                        • The set value pairs that represent the parameters passed to CloudFormation when this nested stack is created. Each parameter has a name corresponding to a parameter defined in the embedded template and a value representing the value that you want to set for the parameter.

                                                                                                                                          > If you use the Ref function to pass a parameter value to a nested stack, comma-delimited list parameters must be of type String . In other words, you can't pass values that are of type CommaDelimitedList to nested stacks.

                                                                                                                                          Conditional. Required if the nested stack requires input parameters.

                                                                                                                                          Whether an update causes interruptions depends on the resources that are being updated. An update never causes a nested stack to be replaced.

                                                                                                                                          http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-stack.html#cfn-cloudformation-stack-parameters

                                                                                                                                        property tags

                                                                                                                                        readonly tags: cdk.TagManager;
                                                                                                                                        • Key-value pairs to associate with this stack. AWS CloudFormation also propagates these tags to the resources created in the stack. A maximum number of 50 tags can be specified.

                                                                                                                                          http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-stack.html#cfn-cloudformation-stack-tags

                                                                                                                                        property templateUrl

                                                                                                                                        templateUrl: string;
                                                                                                                                        • Location of file containing the template body. The URL must point to a template (max size: 460,800 bytes) that's located in an Amazon S3 bucket. For more information, see [Template anatomy](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html) .

                                                                                                                                          Whether an update causes interruptions depends on the resources that are being updated. An update never causes a nested stack to be replaced.

                                                                                                                                          http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-stack.html#cfn-cloudformation-stack-templateurl

                                                                                                                                        property timeoutInMinutes

                                                                                                                                        timeoutInMinutes: number;
                                                                                                                                        • The length of time, in minutes, that CloudFormation waits for the nested stack to reach the CREATE_COMPLETE state. The default is no timeout. When CloudFormation detects that the nested stack has reached the CREATE_COMPLETE state, it marks the nested stack resource as CREATE_COMPLETE in the parent stack and resumes creating the parent stack. If the timeout period expires before the nested stack reaches CREATE_COMPLETE , CloudFormation marks the nested stack as failed and rolls back both the nested stack and parent stack.

                                                                                                                                          Updates aren't supported.

                                                                                                                                          http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-stack.html#cfn-cloudformation-stack-timeoutinminutes

                                                                                                                                        method inspect

                                                                                                                                        inspect: (inspector: cdk.TreeInspector) => void;
                                                                                                                                        • Examines the CloudFormation resource and discloses attributes.

                                                                                                                                          Parameter inspector

                                                                                                                                          tree inspector to collect and process attributes

                                                                                                                                        method renderProperties

                                                                                                                                        protected renderProperties: (props: { [key: string]: any }) => {
                                                                                                                                        [key: string]: any;
                                                                                                                                        };

                                                                                                                                          class CfnStackSet

                                                                                                                                          class CfnStackSet extends cdk.CfnResource implements cdk.IInspectable {}
                                                                                                                                          • A CloudFormation AWS::CloudFormation::StackSet

                                                                                                                                            The AWS::CloudFormation::StackSet enables you to provision stacks into AWS accounts and across Regions by using a single CloudFormation template. In the stack set, you specify the template to use, in addition to any parameters and capabilities that the template requires.

                                                                                                                                            AWS::CloudFormation::StackSet external

                                                                                                                                            http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-stackset.html

                                                                                                                                          constructor

                                                                                                                                          constructor(scope: cdk.Construct, id: string, props: cdk.CfnStackSetProps);
                                                                                                                                          • Create a new AWS::CloudFormation::StackSet.

                                                                                                                                            Parameter scope

                                                                                                                                            scope in which this resource is defined

                                                                                                                                            Parameter id

                                                                                                                                            scoped id of the resource

                                                                                                                                            Parameter props

                                                                                                                                            resource properties

                                                                                                                                          property administrationRoleArn

                                                                                                                                          administrationRoleArn: string;
                                                                                                                                          • The Amazon Resource Number (ARN) of the IAM role to use to create this stack set. Specify an IAM role only if you are using customized administrator roles to control which users or groups can manage specific stack sets within the same administrator account.

                                                                                                                                            Use customized administrator roles to control which users or groups can manage specific stack sets within the same administrator account. For more information, see [Prerequisites: Granting Permissions for Stack Set Operations](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs.html) in the *AWS CloudFormation User Guide* .

                                                                                                                                            *Minimum* : 20

                                                                                                                                            *Maximum* : 2048

                                                                                                                                            http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-stackset.html#cfn-cloudformation-stackset-administrationrolearn

                                                                                                                                          property attrStackSetId

                                                                                                                                          readonly attrStackSetId: string;
                                                                                                                                          • The ID of the stack that you're creating. StackSetId

                                                                                                                                          property autoDeployment

                                                                                                                                          autoDeployment: cdk.IResolvable | cdk.CfnStackSet.AutoDeploymentProperty;
                                                                                                                                          • [ Service-managed permissions] Describes whether StackSets automatically deploys to AWS Organizations accounts that are added to a target organization or organizational unit (OU).

                                                                                                                                            http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-stackset.html#cfn-cloudformation-stackset-autodeployment

                                                                                                                                          property callAs

                                                                                                                                          callAs: string;
                                                                                                                                          • [Service-managed permissions] Specifies whether you are acting as an account administrator in the organization's management account or as a delegated administrator in a member account.

                                                                                                                                            By default, SELF is specified. Use SELF for stack sets with self-managed permissions.

                                                                                                                                            - To create a stack set with service-managed permissions while signed in to the management account, specify SELF . - To create a stack set with service-managed permissions while signed in to a delegated administrator account, specify DELEGATED_ADMIN .

                                                                                                                                            Your AWS account must be registered as a delegated admin in the management account. For more information, see [Register a delegated administrator](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html) in the *AWS CloudFormation User Guide* .

                                                                                                                                            Stack sets with service-managed permissions are created in the management account, including stack sets that are created by delegated administrators.

                                                                                                                                            *Valid Values* : SELF | DELEGATED_ADMIN

                                                                                                                                            http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-stackset.html#cfn-cloudformation-stackset-callas

                                                                                                                                          property capabilities

                                                                                                                                          capabilities: string[];
                                                                                                                                          • The capabilities that are allowed in the stack set. Some stack set templates might include resources that can affect permissions in your AWS account —for example, by creating new AWS Identity and Access Management ( IAM ) users. For more information, see [Acknowledging IAM Resources in AWS CloudFormation Templates](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#capabilities) .

                                                                                                                                            http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-stackset.html#cfn-cloudformation-stackset-capabilities

                                                                                                                                          property CFN_RESOURCE_TYPE_NAME

                                                                                                                                          static readonly CFN_RESOURCE_TYPE_NAME: string;
                                                                                                                                          • The CloudFormation resource type name for this resource class.

                                                                                                                                          property cfnProperties

                                                                                                                                          readonly cfnProperties: { [key: string]: any };

                                                                                                                                            property description

                                                                                                                                            description: string;
                                                                                                                                            • A description of the stack set.

                                                                                                                                              *Minimum* : 1

                                                                                                                                              *Maximum* : 1024

                                                                                                                                              http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-stackset.html#cfn-cloudformation-stackset-description

                                                                                                                                            property executionRoleName

                                                                                                                                            executionRoleName: string;
                                                                                                                                            • The name of the IAM execution role to use to create the stack set. If you don't specify an execution role, AWS CloudFormation uses the AWSCloudFormationStackSetExecutionRole role for the stack set operation.

                                                                                                                                              *Minimum* : 1

                                                                                                                                              *Maximum* : 64

                                                                                                                                              *Pattern* : [a-zA-Z_0-9+=,.@-]+

                                                                                                                                              http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-stackset.html#cfn-cloudformation-stackset-executionrolename

                                                                                                                                            property managedExecution

                                                                                                                                            managedExecution: any;
                                                                                                                                            • Describes whether StackSets performs non-conflicting operations concurrently and queues conflicting operations.

                                                                                                                                              When active, StackSets performs non-conflicting operations concurrently and queues conflicting operations. After conflicting operations finish, StackSets starts queued operations in request order.

                                                                                                                                              > If there are already running or queued operations, StackSets queues all incoming operations even if they are non-conflicting. > > You can't modify your stack set's execution configuration while there are running or queued operations for that stack set.

                                                                                                                                              When inactive (default), StackSets performs one operation at a time in request order.

                                                                                                                                              http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-stackset.html#cfn-cloudformation-stackset-managedexecution

                                                                                                                                            property operationPreferences

                                                                                                                                            operationPreferences:
                                                                                                                                            | cdk.IResolvable
                                                                                                                                            | cdk.CfnStackSet.OperationPreferencesProperty;
                                                                                                                                            • The user-specified preferences for how AWS CloudFormation performs a stack set operation.

                                                                                                                                              http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-stackset.html#cfn-cloudformation-stackset-operationpreferences

                                                                                                                                            property parameters

                                                                                                                                            parameters:
                                                                                                                                            | cdk.IResolvable
                                                                                                                                            | (cdk.IResolvable | cdk.CfnStackSet.ParameterProperty)[];
                                                                                                                                            • The input parameters for the stack set template.

                                                                                                                                              http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-stackset.html#cfn-cloudformation-stackset-parameters

                                                                                                                                            property permissionModel

                                                                                                                                            permissionModel: string;
                                                                                                                                            • Describes how the IAM roles required for stack set operations are created.

                                                                                                                                              - With SELF_MANAGED permissions, you must create the administrator and execution roles required to deploy to target accounts. For more information, see [Grant Self-Managed Stack Set Permissions](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html) . - With SERVICE_MANAGED permissions, StackSets automatically creates the IAM roles required to deploy to accounts managed by AWS Organizations . For more information, see [Grant Service-Managed Stack Set Permissions](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-service-managed.html) .

                                                                                                                                              *Allowed Values* : SERVICE_MANAGED | SELF_MANAGED

                                                                                                                                              > The PermissionModel property is required.

                                                                                                                                              http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-stackset.html#cfn-cloudformation-stackset-permissionmodel

                                                                                                                                            property stackInstancesGroup

                                                                                                                                            stackInstancesGroup:
                                                                                                                                            | cdk.IResolvable
                                                                                                                                            | (cdk.IResolvable | cdk.CfnStackSet.StackInstancesProperty)[];
                                                                                                                                            • A group of stack instances with parameters in some specific accounts and Regions.

                                                                                                                                              http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-stackset.html#cfn-cloudformation-stackset-stackinstancesgroup

                                                                                                                                            property stackSetName

                                                                                                                                            stackSetName: string;
                                                                                                                                            • The name to associate with the stack set. The name must be unique in the Region where you create your stack set.

                                                                                                                                              *Maximum* : 128

                                                                                                                                              *Pattern* : ^[a-zA-Z][a-zA-Z0-9-]{0,127}$

                                                                                                                                              > The StackSetName property is required.

                                                                                                                                              http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-stackset.html#cfn-cloudformation-stackset-stacksetname

                                                                                                                                            property tags

                                                                                                                                            readonly tags: cdk.TagManager;
                                                                                                                                            • The key-value pairs to associate with this stack set and the stacks created from it. AWS CloudFormation also propagates these tags to supported resources that are created in the stacks. A maximum number of 50 tags can be specified.

                                                                                                                                              http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-stackset.html#cfn-cloudformation-stackset-tags

                                                                                                                                            property templateBody

                                                                                                                                            templateBody: string;
                                                                                                                                            • The structure that contains the template body, with a minimum length of 1 byte and a maximum length of 51,200 bytes.

                                                                                                                                              You must include either TemplateURL or TemplateBody in a StackSet, but you can't use both. Dynamic references in the TemplateBody may not work correctly in all cases. It's recommended to pass templates containing dynamic references through TemplateUrl instead.

                                                                                                                                              *Minimum* : 1

                                                                                                                                              *Maximum* : 51200

                                                                                                                                              http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-stackset.html#cfn-cloudformation-stackset-templatebody

                                                                                                                                            property templateUrl

                                                                                                                                            templateUrl: string;
                                                                                                                                            • Location of file containing the template body. The URL must point to a template (max size: 460,800 bytes) that's located in an Amazon S3 bucket.

                                                                                                                                              You must include either TemplateURL or TemplateBody in a StackSet, but you can't use both.

                                                                                                                                              *Minimum* : 1

                                                                                                                                              *Maximum* : 1024

                                                                                                                                              http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-stackset.html#cfn-cloudformation-stackset-templateurl

                                                                                                                                            method inspect

                                                                                                                                            inspect: (inspector: cdk.TreeInspector) => void;
                                                                                                                                            • Examines the CloudFormation resource and discloses attributes.

                                                                                                                                              Parameter inspector

                                                                                                                                              tree inspector to collect and process attributes

                                                                                                                                            method renderProperties

                                                                                                                                            protected renderProperties: (props: { [key: string]: any }) => {
                                                                                                                                            [key: string]: any;
                                                                                                                                            };

                                                                                                                                              class CfnTypeActivation

                                                                                                                                              class CfnTypeActivation extends cdk.CfnResource implements cdk.IInspectable {}
                                                                                                                                              • A CloudFormation AWS::CloudFormation::TypeActivation

                                                                                                                                                Activates a public third-party extension, making it available for use in stack templates. For more information, see [Using public extensions](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry-public.html) in the *AWS CloudFormation User Guide* .

                                                                                                                                                Once you have activated a public third-party extension in your account and region, use [SetTypeConfiguration](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_SetTypeConfiguration.html) to specify configuration properties for the extension. For more information, see [Configuring extensions at the account level](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry-register.html#registry-set-configuration) in the *CloudFormation User Guide* .

                                                                                                                                                AWS::CloudFormation::TypeActivation external

                                                                                                                                                http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-typeactivation.html

                                                                                                                                              constructor

                                                                                                                                              constructor(
                                                                                                                                              scope: cdk.Construct,
                                                                                                                                              id: string,
                                                                                                                                              props?: cdk.CfnTypeActivationProps
                                                                                                                                              );
                                                                                                                                              • Create a new AWS::CloudFormation::TypeActivation.

                                                                                                                                                Parameter scope

                                                                                                                                                scope in which this resource is defined

                                                                                                                                                Parameter id

                                                                                                                                                scoped id of the resource

                                                                                                                                                Parameter props

                                                                                                                                                resource properties

                                                                                                                                              property attrArn

                                                                                                                                              readonly attrArn: string;
                                                                                                                                              • The Amazon Resource Number (ARN) of the activated extension, in this account and Region. Arn

                                                                                                                                              property autoUpdate

                                                                                                                                              autoUpdate: boolean | cdk.IResolvable;
                                                                                                                                              • Whether to automatically update the extension in this account and region when a new *minor* version is published by the extension publisher. Major versions released by the publisher must be manually updated.

                                                                                                                                                The default is true .

                                                                                                                                                http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-typeactivation.html#cfn-cloudformation-typeactivation-autoupdate

                                                                                                                                              property CFN_RESOURCE_TYPE_NAME

                                                                                                                                              static readonly CFN_RESOURCE_TYPE_NAME: string;
                                                                                                                                              • The CloudFormation resource type name for this resource class.

                                                                                                                                              property cfnProperties

                                                                                                                                              readonly cfnProperties: { [key: string]: any };

                                                                                                                                                property executionRoleArn

                                                                                                                                                executionRoleArn: string;
                                                                                                                                                • The name of the IAM execution role to use to activate the extension.

                                                                                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-typeactivation.html#cfn-cloudformation-typeactivation-executionrolearn

                                                                                                                                                property loggingConfig

                                                                                                                                                loggingConfig: cdk.IResolvable | cdk.CfnTypeActivation.LoggingConfigProperty;
                                                                                                                                                • Specifies logging configuration information for an extension.

                                                                                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-typeactivation.html#cfn-cloudformation-typeactivation-loggingconfig

                                                                                                                                                property majorVersion

                                                                                                                                                majorVersion: string;
                                                                                                                                                • The major version of this extension you want to activate, if multiple major versions are available. The default is the latest major version. CloudFormation uses the latest available *minor* version of the major version selected.

                                                                                                                                                  You can specify MajorVersion or VersionBump , but not both.

                                                                                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-typeactivation.html#cfn-cloudformation-typeactivation-majorversion

                                                                                                                                                property publicTypeArn

                                                                                                                                                publicTypeArn: string;
                                                                                                                                                • The Amazon Resource Number (ARN) of the public extension.

                                                                                                                                                  Conditional: You must specify PublicTypeArn , or TypeName , Type , and PublisherId .

                                                                                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-typeactivation.html#cfn-cloudformation-typeactivation-publictypearn

                                                                                                                                                property publisherId

                                                                                                                                                publisherId: string;
                                                                                                                                                • The ID of the extension publisher.

                                                                                                                                                  Conditional: You must specify PublicTypeArn , or TypeName , Type , and PublisherId .

                                                                                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-typeactivation.html#cfn-cloudformation-typeactivation-publisherid

                                                                                                                                                property type

                                                                                                                                                type: string;
                                                                                                                                                • The extension type.

                                                                                                                                                  Conditional: You must specify PublicTypeArn , or TypeName , Type , and PublisherId .

                                                                                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-typeactivation.html#cfn-cloudformation-typeactivation-type

                                                                                                                                                property typeName

                                                                                                                                                typeName: string;
                                                                                                                                                • The name of the extension.

                                                                                                                                                  Conditional: You must specify PublicTypeArn , or TypeName , Type , and PublisherId .

                                                                                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-typeactivation.html#cfn-cloudformation-typeactivation-typename

                                                                                                                                                property typeNameAlias

                                                                                                                                                typeNameAlias: string;
                                                                                                                                                • An alias to assign to the public extension, in this account and region. If you specify an alias for the extension, CloudFormation treats the alias as the extension type name within this account and region. You must use the alias to refer to the extension in your templates, API calls, and CloudFormation console.

                                                                                                                                                  An extension alias must be unique within a given account and region. You can activate the same public resource multiple times in the same account and region, using different type name aliases.

                                                                                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-typeactivation.html#cfn-cloudformation-typeactivation-typenamealias

                                                                                                                                                property versionBump

                                                                                                                                                versionBump: string;
                                                                                                                                                • Manually updates a previously-activated type to a new major or minor version, if available. You can also use this parameter to update the value of AutoUpdate .

                                                                                                                                                  - MAJOR : CloudFormation updates the extension to the newest major version, if one is available. - MINOR : CloudFormation updates the extension to the newest minor version, if one is available.

                                                                                                                                                  http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-typeactivation.html#cfn-cloudformation-typeactivation-versionbump

                                                                                                                                                method inspect

                                                                                                                                                inspect: (inspector: cdk.TreeInspector) => void;
                                                                                                                                                • Examines the CloudFormation resource and discloses attributes.

                                                                                                                                                  Parameter inspector

                                                                                                                                                  tree inspector to collect and process attributes

                                                                                                                                                method renderProperties

                                                                                                                                                protected renderProperties: (props: { [key: string]: any }) => {
                                                                                                                                                [key: string]: any;
                                                                                                                                                };

                                                                                                                                                  class CfnWaitCondition

                                                                                                                                                  class CfnWaitCondition extends cdk.CfnResource implements cdk.IInspectable {}
                                                                                                                                                  • A CloudFormation AWS::CloudFormation::WaitCondition

                                                                                                                                                    > For Amazon EC2 and Auto Scaling resources, we recommend that you use a CreationPolicy attribute instead of wait conditions. Add a CreationPolicy attribute to those resources, and use the cfn-signal helper script to signal when an instance creation process has completed successfully.

                                                                                                                                                    You can use a wait condition for situations like the following:

                                                                                                                                                    - To coordinate stack resource creation with configuration actions that are external to the stack creation. - To track the status of a configuration process.

                                                                                                                                                    For these situations, we recommend that you associate a [CreationPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-creationpolicy.html) attribute with the wait condition so that you don't have to use a wait condition handle. For more information and an example, see [Creating wait conditions in a template](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-waitcondition.html) . If you use a CreationPolicy with a wait condition, don't specify any of the wait condition's properties.

                                                                                                                                                    > If you use the [VPC endpoints](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html) feature, resources in the VPC that respond to wait conditions must have access to CloudFormation , specific Amazon Simple Storage Service ( Amazon S3 ) buckets. Resources must send wait condition responses to a presigned Amazon S3 URL. If they can't send responses to Amazon S3 , CloudFormation won't receive a response and the stack operation fails. For more information, see [Setting up VPC endpoints for AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-vpce-bucketnames.html) .

                                                                                                                                                    AWS::CloudFormation::WaitCondition external

                                                                                                                                                    http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-waitcondition.html

                                                                                                                                                  constructor

                                                                                                                                                  constructor(scope: cdk.Construct, id: string, props?: cdk.CfnWaitConditionProps);
                                                                                                                                                  • Create a new AWS::CloudFormation::WaitCondition.

                                                                                                                                                    Parameter scope

                                                                                                                                                    scope in which this resource is defined

                                                                                                                                                    Parameter id

                                                                                                                                                    scoped id of the resource

                                                                                                                                                    Parameter props

                                                                                                                                                    resource properties

                                                                                                                                                  property attrData

                                                                                                                                                  readonly attrData: cdk.IResolvable;
                                                                                                                                                  • A JSON object that contains the UniqueId and Data values from the wait condition signal(s) for the specified wait condition. For more information about wait condition signals, see [Wait condition signal JSON format](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-waitcondition.html#using-cfn-waitcondition-signaljson) .

                                                                                                                                                    Example return value for a wait condition with 2 signals:

                                                                                                                                                    { "Signal1" : "Step 1 complete." , "Signal2" : "Step 2 complete." } Data

                                                                                                                                                  property CFN_RESOURCE_TYPE_NAME

                                                                                                                                                  static readonly CFN_RESOURCE_TYPE_NAME: string;
                                                                                                                                                  • The CloudFormation resource type name for this resource class.

                                                                                                                                                  property cfnProperties

                                                                                                                                                  readonly cfnProperties: { [key: string]: any };

                                                                                                                                                    property count

                                                                                                                                                    count: number;
                                                                                                                                                    • The number of success signals that CloudFormation must receive before it continues the stack creation process. When the wait condition receives the requisite number of success signals, CloudFormation resumes the creation of the stack. If the wait condition doesn't receive the specified number of success signals before the Timeout period expires, CloudFormation assumes that the wait condition has failed and rolls the stack back.

                                                                                                                                                      Updates aren't supported.

                                                                                                                                                      http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-waitcondition.html#cfn-waitcondition-count

                                                                                                                                                    property handle

                                                                                                                                                    handle: string;
                                                                                                                                                    • A reference to the wait condition handle used to signal this wait condition. Use the Ref intrinsic function to specify an [AWS::CloudFormation::WaitConditionHandle](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-waitconditionhandle.html) resource.

                                                                                                                                                      Anytime you add a WaitCondition resource during a stack update, you must associate the wait condition with a new WaitConditionHandle resource. Don't reuse an old wait condition handle that has already been defined in the template. If you reuse a wait condition handle, the wait condition might evaluate old signals from a previous create or update stack command.

                                                                                                                                                      Updates aren't supported.

                                                                                                                                                      http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-waitcondition.html#cfn-waitcondition-handle

                                                                                                                                                    property timeout

                                                                                                                                                    timeout: string;
                                                                                                                                                    • The length of time (in seconds) to wait for the number of signals that the Count property specifies. Timeout is a minimum-bound property, meaning the timeout occurs no sooner than the time you specify, but can occur shortly thereafter. The maximum time that can be specified for this property is 12 hours (43200 seconds).

                                                                                                                                                      Updates aren't supported.

                                                                                                                                                      http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-waitcondition.html#cfn-waitcondition-timeout

                                                                                                                                                    method inspect

                                                                                                                                                    inspect: (inspector: cdk.TreeInspector) => void;
                                                                                                                                                    • Examines the CloudFormation resource and discloses attributes.

                                                                                                                                                      Parameter inspector

                                                                                                                                                      tree inspector to collect and process attributes

                                                                                                                                                    method renderProperties

                                                                                                                                                    protected renderProperties: (props: { [key: string]: any }) => {
                                                                                                                                                    [key: string]: any;
                                                                                                                                                    };

                                                                                                                                                      class CfnWaitConditionHandle

                                                                                                                                                      class CfnWaitConditionHandle extends cdk.CfnResource implements cdk.IInspectable {}
                                                                                                                                                      • A CloudFormation AWS::CloudFormation::WaitConditionHandle

                                                                                                                                                        > For Amazon EC2 and Auto Scaling resources, we recommend that you use a CreationPolicy attribute instead of wait conditions. Add a CreationPolicy attribute to those resources, and use the cfn-signal helper script to signal when an instance creation process has completed successfully. > > For more information, see [Deploying applications on Amazon EC2 with AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/deploying.applications.html) .

                                                                                                                                                        The AWS::CloudFormation::WaitConditionHandle type has no properties. When you reference the WaitConditionHandle resource by using the Ref function, AWS CloudFormation returns a presigned URL. You pass this URL to applications or scripts that are running on your Amazon EC2 instances to send signals to that URL. An associated AWS::CloudFormation::WaitCondition resource checks the URL for the required number of success signals or for a failure signal.

                                                                                                                                                        > Anytime you add a WaitCondition resource during a stack update or update a resource with a wait condition, you must associate the wait condition with a new WaitConditionHandle resource. Don't reuse an old wait condition handle that has already been defined in the template. If you reuse a wait condition handle, the wait condition might evaluate old signals from a previous create or update stack command. > Updates aren't supported for this resource.

                                                                                                                                                        AWS::CloudFormation::WaitConditionHandle external

                                                                                                                                                        http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-waitconditionhandle.html

                                                                                                                                                      constructor

                                                                                                                                                      constructor(scope: cdk.Construct, id: string);
                                                                                                                                                      • Create a new AWS::CloudFormation::WaitConditionHandle.

                                                                                                                                                        Parameter scope

                                                                                                                                                        scope in which this resource is defined

                                                                                                                                                        Parameter id

                                                                                                                                                        scoped id of the resource

                                                                                                                                                        Parameter props

                                                                                                                                                        resource properties

                                                                                                                                                      property CFN_RESOURCE_TYPE_NAME

                                                                                                                                                      static readonly CFN_RESOURCE_TYPE_NAME: string;
                                                                                                                                                      • The CloudFormation resource type name for this resource class.

                                                                                                                                                      method inspect

                                                                                                                                                      inspect: (inspector: cdk.TreeInspector) => void;
                                                                                                                                                      • Examines the CloudFormation resource and discloses attributes.

                                                                                                                                                        Parameter inspector

                                                                                                                                                        tree inspector to collect and process attributes

                                                                                                                                                      class CliCredentialsStackSynthesizer

                                                                                                                                                      class CliCredentialsStackSynthesizer extends StackSynthesizer {}
                                                                                                                                                      • A synthesizer that uses conventional asset locations, but not conventional deployment roles

                                                                                                                                                        Instead of assuming the bootstrapped deployment roles, all stack operations will be performed using the CLI's current credentials.

                                                                                                                                                        - This synthesizer does not support deploying to accounts to which the CLI does not have credentials. It also does not support deploying using **CDK Pipelines**. For either of those features, use DefaultStackSynthesizer. - This synthesizer requires an S3 bucket and ECR repository with well-known names. To not depend on those, use LegacyStackSynthesizer.

                                                                                                                                                        Be aware that your CLI credentials must be valid for the duration of the entire deployment. If you are using session credentials, make sure the session lifetime is long enough.

                                                                                                                                                        By default, expects the environment to have been bootstrapped with just the staging resources of the Bootstrap Stack V2 (also known as "modern bootstrap stack"). You can override the default names using the synthesizer's construction properties.

                                                                                                                                                      constructor

                                                                                                                                                      constructor(props?: CliCredentialsStackSynthesizerProps);

                                                                                                                                                        method addDockerImageAsset

                                                                                                                                                        addDockerImageAsset: (asset: DockerImageAssetSource) => DockerImageAssetLocation;

                                                                                                                                                          method addFileAsset

                                                                                                                                                          addFileAsset: (asset: FileAssetSource) => FileAssetLocation;

                                                                                                                                                            method bind

                                                                                                                                                            bind: (stack: Stack) => void;

                                                                                                                                                              method synthesize

                                                                                                                                                              synthesize: (session: ISynthesisSession) => void;
                                                                                                                                                              • Synthesize the associated stack to the session

                                                                                                                                                              class ConcreteDependable

                                                                                                                                                              class ConcreteDependable implements IDependable {}
                                                                                                                                                              • A set of constructs to be used as a dependable

                                                                                                                                                                This class can be used when a set of constructs which are disjoint in the construct tree needs to be combined to be used as a single dependable.

                                                                                                                                                              constructor

                                                                                                                                                              constructor();

                                                                                                                                                                method add

                                                                                                                                                                add: (construct: IConstruct) => void;
                                                                                                                                                                • Add a construct to the dependency roots

                                                                                                                                                                class Construct

                                                                                                                                                                class Construct extends constructs.Construct implements IConstruct {}
                                                                                                                                                                • Represents the building block of the construct graph.

                                                                                                                                                                  All constructs besides the root construct must be created within the scope of another construct.

                                                                                                                                                                constructor

                                                                                                                                                                constructor(scope: constructs.Construct, id: string);

                                                                                                                                                                  property node

                                                                                                                                                                  readonly node: ConstructNode;
                                                                                                                                                                  • The construct tree node associated with this construct.

                                                                                                                                                                  method isConstruct

                                                                                                                                                                  static isConstruct: (x: any) => x is Construct;
                                                                                                                                                                  • Return whether the given object is a Construct

                                                                                                                                                                  method onPrepare

                                                                                                                                                                  protected onPrepare: () => void;
                                                                                                                                                                  • Perform final modifications before synthesis

                                                                                                                                                                    This method can be implemented by derived constructs in order to perform final changes before synthesis. prepare() will be called after child constructs have been prepared.

                                                                                                                                                                    This is an advanced framework feature. Only use this if you understand the implications.

                                                                                                                                                                  method onSynthesize

                                                                                                                                                                  protected onSynthesize: (session: constructs.ISynthesisSession) => void;
                                                                                                                                                                  • Allows this construct to emit artifacts into the cloud assembly during synthesis.

                                                                                                                                                                    This method is usually implemented by framework-level constructs such as Stack and Asset as they participate in synthesizing the cloud assembly.

                                                                                                                                                                    Parameter session

                                                                                                                                                                    The synthesis session.

                                                                                                                                                                  method onValidate

                                                                                                                                                                  protected onValidate: () => string[];
                                                                                                                                                                  • Validate the current construct.

                                                                                                                                                                    This method can be implemented by derived constructs in order to perform validation logic. It is called on all constructs before synthesis.

                                                                                                                                                                    Returns

                                                                                                                                                                    An array of validation error messages, or an empty array if the construct is valid.

                                                                                                                                                                  method prepare

                                                                                                                                                                  protected prepare: () => void;
                                                                                                                                                                  • Perform final modifications before synthesis

                                                                                                                                                                    This method can be implemented by derived constructs in order to perform final changes before synthesis. prepare() will be called after child constructs have been prepared.

                                                                                                                                                                    This is an advanced framework feature. Only use this if you understand the implications.

                                                                                                                                                                  method synthesize

                                                                                                                                                                  protected synthesize: (session: ISynthesisSession) => void;
                                                                                                                                                                  • Allows this construct to emit artifacts into the cloud assembly during synthesis.

                                                                                                                                                                    This method is usually implemented by framework-level constructs such as Stack and Asset as they participate in synthesizing the cloud assembly.

                                                                                                                                                                    Parameter session

                                                                                                                                                                    The synthesis session.

                                                                                                                                                                  method validate

                                                                                                                                                                  protected validate: () => string[];
                                                                                                                                                                  • Validate the current construct.

                                                                                                                                                                    This method can be implemented by derived constructs in order to perform validation logic. It is called on all constructs before synthesis.

                                                                                                                                                                    Returns

                                                                                                                                                                    An array of validation error messages, or an empty array if the construct is valid.

                                                                                                                                                                  class ConstructNode

                                                                                                                                                                  class ConstructNode {}
                                                                                                                                                                  • Represents the construct node in the scope tree.

                                                                                                                                                                  constructor

                                                                                                                                                                  constructor(host: Construct, scope: IConstruct, id: string);

                                                                                                                                                                    property addr

                                                                                                                                                                    readonly addr: string;
                                                                                                                                                                    • Returns an opaque tree-unique address for this construct.

                                                                                                                                                                      Addresses are 42 characters hexadecimal strings. They begin with "c8" followed by 40 lowercase hexadecimal characters (0-9a-f).

                                                                                                                                                                      Addresses are calculated using a SHA-1 of the components of the construct path.

                                                                                                                                                                      To enable refactorings of construct trees, constructs with the ID Default will be excluded from the calculation. In those cases constructs in the same tree may have the same addreess.

                                                                                                                                                                      Example value: c83a2846e506bcc5f10682b564084bca2d275709ee

                                                                                                                                                                    property children

                                                                                                                                                                    readonly children: IConstruct[];
                                                                                                                                                                    • All direct children of this construct.

                                                                                                                                                                    property defaultChild

                                                                                                                                                                    defaultChild: IConstruct;
                                                                                                                                                                    • Returns the child construct that has the id Default or Resource". This is usually the construct that provides the bulk of the underlying functionality. Useful for modifications of the underlying construct that are not available at the higher levels.

                                                                                                                                                                      Returns

                                                                                                                                                                      a construct or undefined if there is no default child

                                                                                                                                                                      Throws

                                                                                                                                                                      if there is more than one child

                                                                                                                                                                    property dependencies

                                                                                                                                                                    readonly dependencies: Dependency[];
                                                                                                                                                                    • Return all dependencies registered on this node or any of its children

                                                                                                                                                                    property id

                                                                                                                                                                    readonly id: string;
                                                                                                                                                                    • The id of this construct within the current scope.

                                                                                                                                                                      This is a a scope-unique id. To obtain an app-unique id for this construct, use uniqueId.

                                                                                                                                                                    property locked

                                                                                                                                                                    readonly locked: boolean;
                                                                                                                                                                    • Returns true if this construct or the scopes in which it is defined are locked.

                                                                                                                                                                    property metadata

                                                                                                                                                                    readonly metadata: cxapi.MetadataEntry[];
                                                                                                                                                                    • DEPRECATED

                                                                                                                                                                      Deprecated

                                                                                                                                                                      use metadataEntry

                                                                                                                                                                    property metadataEntry

                                                                                                                                                                    readonly metadataEntry: constructs.MetadataEntry[];
                                                                                                                                                                    • An immutable array of metadata objects associated with this construct. This can be used, for example, to implement support for deprecation notices, source mapping, etc.

                                                                                                                                                                    property path

                                                                                                                                                                    readonly path: string;
                                                                                                                                                                    • The full, absolute path of this construct in the tree.

                                                                                                                                                                      Components are separated by '/'.

                                                                                                                                                                    property PATH_SEP

                                                                                                                                                                    static readonly PATH_SEP: string;
                                                                                                                                                                    • Separator used to delimit construct path components.

                                                                                                                                                                    property root

                                                                                                                                                                    readonly root: IConstruct;
                                                                                                                                                                    • Returns

                                                                                                                                                                      The root of the construct tree.

                                                                                                                                                                    property scope

                                                                                                                                                                    readonly scope: IConstruct;
                                                                                                                                                                    • Returns the scope in which this construct is defined.

                                                                                                                                                                      The value is undefined at the root of the construct scope tree.

                                                                                                                                                                    property scopes

                                                                                                                                                                    readonly scopes: IConstruct[];
                                                                                                                                                                    • All parent scopes of this construct.

                                                                                                                                                                      Returns

                                                                                                                                                                      a list of parent scopes. The last element in the list will always be the current construct and the first element will be the root of the tree.

                                                                                                                                                                    property uniqueId

                                                                                                                                                                    readonly uniqueId: string;
                                                                                                                                                                    • A tree-global unique alphanumeric identifier for this construct. Includes all components of the tree.

                                                                                                                                                                      Deprecated

                                                                                                                                                                      use node.addr to obtain a consistent 42 character address for this node (see https://github.com/aws/constructs/pull/314). Alternatively, to get a CloudFormation-compatible unique identifier, use Names.uniqueId().

                                                                                                                                                                    method addDependency

                                                                                                                                                                    addDependency: (...dependencies: IDependable[]) => void;
                                                                                                                                                                    • Add an ordering dependency on another Construct.

                                                                                                                                                                      All constructs in the dependency's scope will be deployed before any construct in this construct's scope.

                                                                                                                                                                    method addError

                                                                                                                                                                    addError: (message: string) => void;
                                                                                                                                                                    • DEPRECATED: Adds an { "error": } metadata entry to this construct. The toolkit will fail synthesis when errors are reported.

                                                                                                                                                                      Parameter message

                                                                                                                                                                      The error message.

                                                                                                                                                                      Deprecated

                                                                                                                                                                      use Annotations.of(construct).addError()

                                                                                                                                                                    method addInfo

                                                                                                                                                                    addInfo: (message: string) => void;
                                                                                                                                                                    • DEPRECATED: Adds a { "info": } metadata entry to this construct. The toolkit will display the info message when apps are synthesized.

                                                                                                                                                                      Parameter message

                                                                                                                                                                      The info message.

                                                                                                                                                                      Deprecated

                                                                                                                                                                      use Annotations.of(construct).addInfo()

                                                                                                                                                                    method addMetadata

                                                                                                                                                                    addMetadata: (type: string, data: any, fromFunction?: any) => void;
                                                                                                                                                                    • Adds a metadata entry to this construct. Entries are arbitrary values and will also include a stack trace to allow tracing back to the code location for when the entry was added. It can be used, for example, to include source mapping in CloudFormation templates to improve diagnostics.

                                                                                                                                                                      Parameter type

                                                                                                                                                                      a string denoting the type of metadata

                                                                                                                                                                      Parameter data

                                                                                                                                                                      the value of the metadata (can be a Token). If null/undefined, metadata will not be added.

                                                                                                                                                                      Parameter fromFunction

                                                                                                                                                                      a function under which to restrict the metadata entry's stack trace (defaults to this.addMetadata)

                                                                                                                                                                    method addValidation