cloudformation-declarations/out/declarations/generated/aws-cloudformation.js

TypeScript declarations and helpers for writing CloudFormation templates in TS or JS.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var AWS;
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::Account resource specifies the AWS Identity and Access Management  (IAM) role that Amazon
        API Gateway (API Gateway) uses to write API logs to Amazon CloudWatch Logs (CloudWatch
        Logs).
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-account.html
         */
        function Account(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::Account' }, props);
        }
        ApiGateway.Account = Account;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::ApiKey resource creates a unique key that you can distribute to clients who are executing
        Amazon API Gateway (API Gateway) Method resources that require an API key. To specify which API key clients must use, map
        the API key with the RestApi and Stage resources that include the methods requiring a key.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html
         */
        function ApiKey(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::ApiKey' }, props);
        }
        ApiGateway.ApiKey = ApiKey;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::Authorizer resource creates an authorization layer that Amazon API Gateway (API Gateway) activates
        for methods that have authorization enabled. API Gateway activates the authorizer
        when a client calls those methods.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-authorizer.html
         */
        function Authorizer(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::Authorizer' }, props);
        }
        ApiGateway.Authorizer = Authorizer;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::BasePathMapping resource creates a base path that clients who call your Amazon API Gateway API must
        use in the invocation URL.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-basepathmapping.html
         */
        function BasePathMapping(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::BasePathMapping' }, props);
        }
        ApiGateway.BasePathMapping = BasePathMapping;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::ClientCertificate resource creates a client certificate that Amazon API Gateway (API Gateway) uses
        to configure client-side SSL authentication for sending requests to the integration
        endpoint.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-clientcertificate.html
         */
        function ClientCertificate(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::ClientCertificate' }, props);
        }
        ApiGateway.ClientCertificate = ClientCertificate;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::Deployment resource deploys an Amazon API Gateway (API Gateway) RestApi resource to a stage so that clients can call the API over the Internet. The stage
        acts as an environment.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-deployment.html
         */
        function Deployment(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::Deployment' }, props);
        }
        ApiGateway.Deployment = Deployment;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::DocumentationPart resource creates a documentation
        part for an Amazon API Gateway API entity. For more information, see  Representation of API Documentation in API Gateway in the
        API Gateway Developer Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-documentationpart.html
         */
        function DocumentationPart(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::DocumentationPart' }, props);
        }
        ApiGateway.DocumentationPart = DocumentationPart;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::DocumentationVersion resource creates a snapshot of
        the documentation for an Amazon API Gateway API entity. For more information, see
        Representation of API Documentation in API Gateway in the
        API Gateway Developer Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-documentationversion.html
         */
        function DocumentationVersion(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::DocumentationVersion' }, props);
        }
        ApiGateway.DocumentationVersion = DocumentationVersion;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::DomainName resource specifies a custom domain name for your API in Amazon API Gateway (API Gateway).
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-domainname.html
         */
        function DomainName(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::DomainName' }, props);
        }
        ApiGateway.DomainName = DomainName;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The
        AWS::ApiGateway::GatewayResponse resource creates
        a custom response for your API Gateway API. For more information, see API Gateway Responses
            in the API Gateway Developer Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-gatewayresponse.html
         */
        function GatewayResponse(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::GatewayResponse' }, props);
        }
        ApiGateway.GatewayResponse = GatewayResponse;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::Method resource creates Amazon API Gateway (API Gateway) methods that define the parameters
        and body that clients must send in their requests.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-method.html
         */
        function Method(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::Method' }, props);
        }
        ApiGateway.Method = Method;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::Model resource defines the structure of a request or response payload for an Amazon API
        Gateway (API Gateway) method.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-model.html
         */
        function Model(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::Model' }, props);
        }
        ApiGateway.Model = Model;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::RequestValidator resource sets up basic validation rules for incoming
        requests to your API Gateway API.
        For more information, see
        
           Enable Basic Request Validation for an API in API Gateway in the API Gateway Developer Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-requestvalidator.html
         */
        function RequestValidator(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::RequestValidator' }, props);
        }
        ApiGateway.RequestValidator = RequestValidator;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::Resource resource creates a resource in an Amazon API Gateway (API Gateway) API.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-resource.html
         */
        function Resource(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::Resource' }, props);
        }
        ApiGateway.Resource = Resource;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::RestApi resource contains a collection of Amazon API Gateway
        resources and methods that can be invoked through HTTPS endpoints. For more information,
        see
        restapi:create in the Amazon API Gateway REST API Reference.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-restapi.html
         */
        function RestApi(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::RestApi' }, props);
        }
        ApiGateway.RestApi = RestApi;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::Stage resource creates a stage for an Amazon API Gateway (API Gateway) deployment.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-stage.html
         */
        function Stage(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::Stage' }, props);
        }
        ApiGateway.Stage = Stage;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::UsagePlan resource specifies a usage plan for deployed Amazon API Gateway (API Gateway) APIs.
        A usage plan enforces throttling and quota limits on individual client API keys. For
        more information, see Creating and Using API Usage Plans in Amazon API Gateway in the API Gateway Developer Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-usageplan.html
         */
        function UsagePlan(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::UsagePlan' }, props);
        }
        ApiGateway.UsagePlan = UsagePlan;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::UsagePlanKey resource associates an Amazon API Gateway API key with
        an API Gateway usage plan. This association determines which users the usage plan
        is applied
        to.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-usageplankey.html
         */
        function UsagePlanKey(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::UsagePlanKey' }, props);
        }
        ApiGateway.UsagePlanKey = UsagePlanKey;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApplicationAutoScaling;
    (function (ApplicationAutoScaling) {
        /**
         * The AWS::ApplicationAutoScaling::ScalableTarget resource specifies a resource that Application Auto Scaling can scale up or down.
        For more information, see the RegisterScalableTarget action in the Application Auto Scaling API Reference.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-applicationautoscaling-scalabletarget.html
         */
        function ScalableTarget(props) {
            return Object.assign({ Type: 'AWS::ApplicationAutoScaling::ScalableTarget' }, props);
        }
        ApplicationAutoScaling.ScalableTarget = ScalableTarget;
    })(ApplicationAutoScaling = AWS.ApplicationAutoScaling || (AWS.ApplicationAutoScaling = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var ApplicationAutoScaling;
    (function (ApplicationAutoScaling) {
        /**
         * The AWS::ApplicationAutoScaling::ScalingPolicy resource defines an Application Auto Scaling scaling policy that Application Auto
        Scaling uses to adjust your application resources.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-applicationautoscaling-scalingpolicy.html
         */
        function ScalingPolicy(props) {
            return Object.assign({ Type: 'AWS::ApplicationAutoScaling::ScalingPolicy' }, props);
        }
        ApplicationAutoScaling.ScalingPolicy = ScalingPolicy;
    })(ApplicationAutoScaling = AWS.ApplicationAutoScaling || (AWS.ApplicationAutoScaling = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var AutoScaling;
    (function (AutoScaling) {
        /**
         * The AWS::AutoScaling::AutoScalingGroup type creates an Auto Scaling group.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-as-group.html
         */
        function AutoScalingGroup(props) {
            return Object.assign({ Type: 'AWS::AutoScaling::AutoScalingGroup' }, props);
        }
        AutoScaling.AutoScalingGroup = AutoScalingGroup;
    })(AutoScaling = AWS.AutoScaling || (AWS.AutoScaling = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var AutoScaling;
    (function (AutoScaling) {
        /**
         * The AWS::AutoScaling::LaunchConfiguration type creates an Auto Scaling launch
        configuration that can be used by an Auto Scaling group to configure Amazon EC2 instances
        in the Auto Scaling
        group.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-as-launchconfig.html
         */
        function LaunchConfiguration(props) {
            return Object.assign({ Type: 'AWS::AutoScaling::LaunchConfiguration' }, props);
        }
        AutoScaling.LaunchConfiguration = LaunchConfiguration;
    })(AutoScaling = AWS.AutoScaling || (AWS.AutoScaling = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var AutoScaling;
    (function (AutoScaling) {
        /**
         * Use AWS::AutoScaling::LifecycleHook to control the state of an instance in an Auto Scaling group after it is launched
        or terminated. When you use a lifecycle hook, the Auto Scaling group either pauses
        the instance after it is launched (before it is put into service) or pauses the instance
        as it is terminated (before it is fully terminated). For more information, see Examples of How to Use Lifecycle Hooks in the
        Auto Scaling User Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-as-lifecyclehook.html
         */
        function LifecycleHook(props) {
            return Object.assign({ Type: 'AWS::AutoScaling::LifecycleHook' }, props);
        }
        AutoScaling.LifecycleHook = LifecycleHook;
    })(AutoScaling = AWS.AutoScaling || (AWS.AutoScaling = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var AutoScaling;
    (function (AutoScaling) {
        /**
         * The AWS::AutoScaling::ScalingPolicy resource adds a scaling policy to an auto scaling group. A
        scaling policy specifies whether to scale the auto scaling group up or down, and by
        how much. For more information
        on scaling policies, see Scaling by Policy in the Auto Scaling Developer Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-as-policy.html
         */
        function ScalingPolicy(props) {
            return Object.assign({ Type: 'AWS::AutoScaling::ScalingPolicy' }, props);
        }
        AutoScaling.ScalingPolicy = ScalingPolicy;
    })(AutoScaling = AWS.AutoScaling || (AWS.AutoScaling = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var AutoScaling;
    (function (AutoScaling) {
        /**
         * Creates a scheduled scaling action for an Auto Scaling group, changing the number
        of servers
        available for your application in response to predictable load changes.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-as-scheduledaction.html
         */
        function ScheduledAction(props) {
            return Object.assign({ Type: 'AWS::AutoScaling::ScheduledAction' }, props);
        }
        AutoScaling.ScheduledAction = ScheduledAction;
    })(AutoScaling = AWS.AutoScaling || (AWS.AutoScaling = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var Batch;
    (function (Batch) {
        /**
         * The AWS::Batch::ComputeEnvironment resource to define your AWS Batch compute
        environment. For more information, see Compute Environments in
        the AWS Batch User Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-computeenvironment.html
         */
        function ComputeEnvironment(props) {
            return Object.assign({ Type: 'AWS::Batch::ComputeEnvironment' }, props);
        }
        Batch.ComputeEnvironment = ComputeEnvironment;
    })(Batch = AWS.Batch || (AWS.Batch = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var Batch;
    (function (Batch) {
        /**
         * The AWS::Batch::JobDefinition resource specifies the parameters for an
        AWS Batch job definition. For more information, see Job Definitions in the
        AWS Batch User Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-jobdefinition.html
         */
        function JobDefinition(props) {
            return Object.assign({ Type: 'AWS::Batch::JobDefinition' }, props);
        }
        Batch.JobDefinition = JobDefinition;
    })(Batch = AWS.Batch || (AWS.Batch = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var Batch;
    (function (Batch) {
        /**
         * The AWS::Batch::JobQueue resource defines your AWS Batch job queue. For more
        information, see Job
           Queues in the AWS Batch User Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-jobqueue.html
         */
        function JobQueue(props) {
            return Object.assign({ Type: 'AWS::Batch::JobQueue' }, props);
        }
        Batch.JobQueue = JobQueue;
    })(Batch = AWS.Batch || (AWS.Batch = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var CertificateManager;
    (function (CertificateManager) {
        /**
         * The AWS::CertificateManager::Certificate resource requests an AWS Certificate Manager
        (ACM) certificate that you can use with AWS services to enable secure connections.
        For
        example, you can deploy an ACM certificate to an Elastic Load Balancing load balancer
        to enable HTTPS
        support. For more information, see the RequestCertificate action
        in the AWS Certificate Manager API Reference.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html
         */
        function Certificate(props) {
            return Object.assign({ Type: 'AWS::CertificateManager::Certificate' }, props);
        }
        CertificateManager.Certificate = Certificate;
    })(CertificateManager = AWS.CertificateManager || (AWS.CertificateManager = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var CloudFormation;
    (function (CloudFormation) {
        /**
         * In an AWS CloudFormation template, you use the AWS::CloudFormation::CustomResource or Custom::String resource type to specify custom resources.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cfn-customresource.html
         */
        function CustomResource(props) {
            return Object.assign({ Type: 'AWS::CloudFormation::CustomResource' }, props);
        }
        CloudFormation.CustomResource = CustomResource;
    })(CloudFormation = AWS.CloudFormation || (AWS.CloudFormation = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var CloudFormation;
    (function (CloudFormation) {
        /**
         * The AWS::CloudFormation::Stack type nests a stack as a resource in a top-level
        template.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-stack.html
         */
        function Stack(props) {
            return Object.assign({ Type: 'AWS::CloudFormation::Stack' }, props);
        }
        CloudFormation.Stack = Stack;
    })(CloudFormation = AWS.CloudFormation || (AWS.CloudFormation = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var CloudFormation;
    (function (CloudFormation) {
        /**
         *
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-waitcondition.html
         */
        function WaitCondition(props) {
            return Object.assign({ Type: 'AWS::CloudFormation::WaitCondition' }, props);
        }
        CloudFormation.WaitCondition = WaitCondition;
    })(CloudFormation = AWS.CloudFormation || (AWS.CloudFormation = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var CloudFormation;
    (function (CloudFormation) {
        /**
         *
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-waitconditionhandle.html
         */
        function WaitConditionHandle(props) {
            return Object.assign({ Type: 'AWS::CloudFormation::WaitConditionHandle' }, props);
        }
        CloudFormation.WaitConditionHandle = WaitConditionHandle;
    })(CloudFormation = AWS.CloudFormation || (AWS.CloudFormation = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var CloudFront;
    (function (CloudFront) {
        /**
         * Creates an Amazon CloudFront web distribution. For general information about CloudFront
        distributions, see
        the Introduction to Amazon CloudFront in
        the Amazon CloudFront Developer Guide. For specific information about creating CloudFront web
        distributions, see CreateDistribution in the Amazon CloudFront API Reference.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cloudfront-distribution.html
         */
        function Distribution(props) {
            return Object.assign({ Type: 'AWS::CloudFront::Distribution' }, props);
        }
        CloudFront.Distribution = Distribution;
    })(CloudFront = AWS.CloudFront || (AWS.CloudFront = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var CloudTrail;
    (function (CloudTrail) {
        /**
         * Use the AWS::CloudTrail::Trail resource to create a trail and specify where
        logs are published. An AWS CloudTrail (CloudTrail) trail can capture AWS API calls
        made by your AWS account
        and publish the logs to an Amazon S3 bucket. For more information, see What is AWS CloudTrail? in the
        AWS CloudTrail User Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudtrail-trail.html
         */
        function Trail(props) {
            return Object.assign({ Type: 'AWS::CloudTrail::Trail' }, props);
        }
        CloudTrail.Trail = Trail;
    })(CloudTrail = AWS.CloudTrail || (AWS.CloudTrail = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var CloudWatch;
    (function (CloudWatch) {
        /**
         * The AWS::CloudWatch::Alarm type creates a CloudWatch alarm.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cw-alarm.html
         */
        function Alarm(props) {
            return Object.assign({ Type: 'AWS::CloudWatch::Alarm' }, props);
        }
        CloudWatch.Alarm = Alarm;
    })(CloudWatch = AWS.CloudWatch || (AWS.CloudWatch = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var CloudWatch;
    (function (CloudWatch) {
        /**
         *
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudwatch-dashboard.html
         */
        function Dashboard(props) {
            return Object.assign({ Type: 'AWS::CloudWatch::Dashboard' }, props);
        }
        CloudWatch.Dashboard = Dashboard;
    })(CloudWatch = AWS.CloudWatch || (AWS.CloudWatch = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var CodeBuild;
    (function (CodeBuild) {
        /**
         * The AWS::CodeBuild::Project resource configures how AWS CodeBuild builds your source
        code. For example, it tells AWS CodeBuild where to get the source code and which build
        environment to
        use.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-project.html
         */
        function Project(props) {
            return Object.assign({ Type: 'AWS::CodeBuild::Project' }, props);
        }
        CodeBuild.Project = Project;
    })(CodeBuild = AWS.CodeBuild || (AWS.CodeBuild = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var CodeCommit;
    (function (CodeCommit) {
        /**
         * The AWS::CodeCommit::Repository resource creates an AWS CodeCommit repository that is
        hosted by Amazon Web Services. For more information, see Create an AWS CodeCommit Repository in the
        AWS CodeCommit User Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codecommit-repository.html
         */
        function Repository(props) {
            return Object.assign({ Type: 'AWS::CodeCommit::Repository' }, props);
        }
        CodeCommit.Repository = Repository;
    })(CodeCommit = AWS.CodeCommit || (AWS.CodeCommit = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var CodeDeploy;
    (function (CodeDeploy) {
        /**
         * The AWS::CodeDeploy::Application resource creates an AWS CodeDeploy application. In AWS CodeDeploy, an application
        is a name that functions as a container
        to ensure that the correct combination of revision, deployment configuration, and
        deployment group are referenced during a deployment.
        You can use the AWS::CodeDeploy::DeploymentGroup resource to associate the application with an AWS CodeDeploy deployment group.
        For more information, see AWS CodeDeploy Deployments in the AWS CodeDeploy User Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codedeploy-application.html
         */
        function Application(props) {
            return Object.assign({ Type: 'AWS::CodeDeploy::Application' }, props);
        }
        CodeDeploy.Application = Application;
    })(CodeDeploy = AWS.CodeDeploy || (AWS.CodeDeploy = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var CodeDeploy;
    (function (CodeDeploy) {
        /**
         * The AWS::CodeDeploy::DeploymentConfig resource creates a set of deployment
        rules, deployment success conditions, and deployment failure conditions that AWS CodeDeploy
        uses during a
        deployment. The deployment configuration specifies, through the use of a MinimumHealthyHosts value,
        the number or percentage of instances that must remain available at any time during
        a deployment.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codedeploy-deploymentconfig.html
         */
        function DeploymentConfig(props) {
            return Object.assign({ Type: 'AWS::CodeDeploy::DeploymentConfig' }, props);
        }
        CodeDeploy.DeploymentConfig = DeploymentConfig;
    })(CodeDeploy = AWS.CodeDeploy || (AWS.CodeDeploy = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var CodeDeploy;
    (function (CodeDeploy) {
        /**
         * The AWS::CodeDeploy::DeploymentGroup resource creates an AWS CodeDeploy deployment
        group that specifies which instances your application revisions are deployed to, along
        with other deployment options.
        For more information, see CreateDeploymentGroup in the AWS CodeDeploy API Reference.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codedeploy-deploymentgroup.html
         */
        function DeploymentGroup(props) {
            return Object.assign({ Type: 'AWS::CodeDeploy::DeploymentGroup' }, props);
        }
        CodeDeploy.DeploymentGroup = DeploymentGroup;
    })(CodeDeploy = AWS.CodeDeploy || (AWS.CodeDeploy = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var CodePipeline;
    (function (CodePipeline) {
        /**
         * The AWS::CodePipeline::CustomActionType resource creates a custom action for
        activities that aren't included in the AWS CodePipeline default actions, such as running
        an internally
        developed build process or a test suite. You can use these custom actions in the stage
        of a
        pipeline. For more information,
        see Create and Add a Custom Action
           in AWS CodePipeline in the AWS CodePipeline User Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-customactiontype.html
         */
        function CustomActionType(props) {
            return Object.assign({ Type: 'AWS::CodePipeline::CustomActionType' }, props);
        }
        CodePipeline.CustomActionType = CustomActionType;
    })(CodePipeline = AWS.CodePipeline || (AWS.CodePipeline = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var CodePipeline;
    (function (CodePipeline) {
        /**
         * The AWS::CodePipeline::Pipeline resource creates an AWS CodePipeline pipeline that
        describes how software changes go through a release process. For more information,
        see What Is AWS CodePipeline? in the
        AWS CodePipeline User Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html
         */
        function Pipeline(props) {
            return Object.assign({ Type: 'AWS::CodePipeline::Pipeline' }, props);
        }
        CodePipeline.Pipeline = Pipeline;
    })(CodePipeline = AWS.CodePipeline || (AWS.CodePipeline = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var Cognito;
    (function (Cognito) {
        /**
         * The AWS::Cognito::IdentityPool resource creates an Amazon Cognito
        identity
        pool.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-identitypool.html
         */
        function IdentityPool(props) {
            return Object.assign({ Type: 'AWS::Cognito::IdentityPool' }, props);
        }
        Cognito.IdentityPool = IdentityPool;
    })(Cognito = AWS.Cognito || (AWS.Cognito = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var Cognito;
    (function (Cognito) {
        /**
         * The AWS::Cognito::IdentityPoolRoleAttachment resource manages the role configuration for an Amazon Cognito identity pool.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-identitypoolroleattachment.html
         */
        function IdentityPoolRoleAttachment(props) {
            return Object.assign({ Type: 'AWS::Cognito::IdentityPoolRoleAttachment' }, props);
        }
        Cognito.IdentityPoolRoleAttachment = IdentityPoolRoleAttachment;
    })(Cognito = AWS.Cognito || (AWS.Cognito = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var Cognito;
    (function (Cognito) {
        /**
         * The AWS::Cognito::UserPool resource creates an Amazon Cognito user pool.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-userpool.html
         */
        function UserPool(props) {
            return Object.assign({ Type: 'AWS::Cognito::UserPool' }, props);
        }
        Cognito.UserPool = UserPool;
    })(Cognito = AWS.Cognito || (AWS.Cognito = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var Cognito;
    (function (Cognito) {
        /**
         * The AWS::Cognito::UserPoolClient resource creates an Amazon Cognito user pool client.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-userpoolclient.html
         */
        function UserPoolClient(props) {
            return Object.assign({ Type: 'AWS::Cognito::UserPoolClient' }, props);
        }
        Cognito.UserPoolClient = UserPoolClient;
    })(Cognito = AWS.Cognito || (AWS.Cognito = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var Cognito;
    (function (Cognito) {
        /**
         * The AWS::Cognito::UserPoolGroup resource creates a user group in an Amazon Cognito user pool.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-userpoolgroup.html
         */
        function UserPoolGroup(props) {
            return Object.assign({ Type: 'AWS::Cognito::UserPoolGroup' }, props);
        }
        Cognito.UserPoolGroup = UserPoolGroup;
    })(Cognito = AWS.Cognito || (AWS.Cognito = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var Cognito;
    (function (Cognito) {
        /**
         * The AWS::Cognito::UserPoolUser resource creates an Amazon Cognito user pool user.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-userpooluser.html
         */
        function UserPoolUser(props) {
            return Object.assign({ Type: 'AWS::Cognito::UserPoolUser' }, props);
        }
        Cognito.UserPoolUser = UserPoolUser;
    })(Cognito = AWS.Cognito || (AWS.Cognito = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var Cognito;
    (function (Cognito) {
        /**
         * The AWS::Cognito::UserPoolUserToGroupAttachment resource attaches a user to an Amazon Cognito user pool user group.
        
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-userpoolusertogroupattachment.html
         */
        function UserPoolUserToGroupAttachment(props) {
            return Object.assign({ Type: 'AWS::Cognito::UserPoolUserToGroupAttachment' }, props);
        }
        Cognito.UserPoolUserToGroupAttachment = UserPoolUserToGroupAttachment;
    })(Cognito = AWS.Cognito || (AWS.Cognito = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var Config;
    (function (Config) {
        /**
         * The AWS::Config::ConfigRule resource uses an AWS Lambda (Lambda) function that
        evaluates configuration items to assess whether your AWS resources comply with your
        specified
        configurations. This function can run when AWS Config detects a configuration change
        or delivers a
        configuration snapshot. The resources this function evaluates must be in the recording
        group.
        For more information, see Evaluating AWS Resource
           Configurations with AWS Config in the AWS Config Developer Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-config-configrule.html
         */
        function ConfigRule(props) {
            return Object.assign({ Type: 'AWS::Config::ConfigRule' }, props);
        }
        Config.ConfigRule = ConfigRule;
    })(Config = AWS.Config || (AWS.Config = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var Config;
    (function (Config) {
        /**
         * The AWS::Config::ConfigurationRecorder resource describes the AWS resource
        types for which AWS Config records configuration changes. The configuration recorder
        stores the
        configurations of the supported resources in your account as configuration items.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-config-configurationrecorder.html
         */
        function ConfigurationRecorder(props) {
            return Object.assign({ Type: 'AWS::Config::ConfigurationRecorder' }, props);
        }
        Config.ConfigurationRecorder = ConfigurationRecorder;
    })(Config = AWS.Config || (AWS.Config = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var Config;
    (function (Config) {
        /**
         * The AWS::Config::DeliveryChannel resource describes where AWS Config sends
        notifications and updated configuration states for AWS resources.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-config-deliverychannel.html
         */
        function DeliveryChannel(props) {
            return Object.assign({ Type: 'AWS::Config::DeliveryChannel' }, props);
        }
        Config.DeliveryChannel = DeliveryChannel;
    })(Config = AWS.Config || (AWS.Config = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var DAX;
    (function (DAX) {
        /**
         * Use the AWS::DAX::Cluster resource to create a DAX cluster for use
        with Amazon DynamoDB.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dax-cluster.html
         */
        function Cluster(props) {
            return Object.assign({ Type: 'AWS::DAX::Cluster' }, props);
        }
        DAX.Cluster = Cluster;
    })(DAX = AWS.DAX || (AWS.DAX = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var DAX;
    (function (DAX) {
        /**
         * Use the AWS CloudFormation AWS::DAX::ParameterGroup resource to create a parameter group
        for use with Amazon DynamoDB.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dax-parametergroup.html
         */
        function ParameterGroup(props) {
            return Object.assign({ Type: 'AWS::DAX::ParameterGroup' }, props);
        }
        DAX.ParameterGroup = ParameterGroup;
    })(DAX = AWS.DAX || (AWS.DAX = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var DAX;
    (function (DAX) {
        /**
         * Use the AWS CloudFormation AWS::DAX::SubnetGroup resource to create a subnet group for use
        with DAX (DynamoDB Accelerator).
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dax-subnetgroup.html
         */
        function SubnetGroup(props) {
            return Object.assign({ Type: 'AWS::DAX::SubnetGroup' }, props);
        }
        DAX.SubnetGroup = SubnetGroup;
    })(DAX = AWS.DAX || (AWS.DAX = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var DMS;
    (function (DMS) {
        /**
         * The AWS::DMS::Certificate resource creates an SSL certificate that encrypts connections between AWS DMS endpoints
        and the replication instance.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dms-certificate.html
         */
        function Certificate(props) {
            return Object.assign({ Type: 'AWS::DMS::Certificate' }, props);
        }
        DMS.Certificate = Certificate;
    })(DMS = AWS.DMS || (AWS.DMS = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var DMS;
    (function (DMS) {
        /**
         * The AWS::DMS::Endpoint resource creates an AWS DMS endpoint.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dms-endpoint.html
         */
        function Endpoint(props) {
            return Object.assign({ Type: 'AWS::DMS::Endpoint' }, props);
        }
        DMS.Endpoint = Endpoint;
    })(DMS = AWS.DMS || (AWS.DMS = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var DMS;
    (function (DMS) {
        /**
         * Use the AWS::DMS::EventSubscription resource to get notifications for
        AWS Database Migration Service events through the Amazon Simple Notification Service.
        For more information, see Using AWS DMS Event Notification in the
        AWS Database Migration Service User Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dms-eventsubscription.html
         */
        function EventSubscription(props) {
            return Object.assign({ Type: 'AWS::DMS::EventSubscription' }, props);
        }
        DMS.EventSubscription = EventSubscription;
    })(DMS = AWS.DMS || (AWS.DMS = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var DMS;
    (function (DMS) {
        /**
         * The AWS::DMS::ReplicationInstance resource creates an AWS DMS replication instance.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dms-replicationinstance.html
         */
        function ReplicationInstance(props) {
            return Object.assign({ Type: 'AWS::DMS::ReplicationInstance' }, props);
        }
        DMS.ReplicationInstance = ReplicationInstance;
    })(DMS = AWS.DMS || (AWS.DMS = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var DMS;
    (function (DMS) {
        /**
         *
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dms-replicationsubnetgroup.html
         */
        function ReplicationSubnetGroup(props) {
            return Object.assign({ Type: 'AWS::DMS::ReplicationSubnetGroup' }, props);
        }
        DMS.ReplicationSubnetGroup = ReplicationSubnetGroup;
    })(DMS = AWS.DMS || (AWS.DMS = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var DMS;
    (function (DMS) {
        /**
         * The AWS::DMS::ReplicationTask resource creates an AWS DMS replication task.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dms-replicationtask.html
         */
        function ReplicationTask(props) {
            return Object.assign({ Type: 'AWS::DMS::ReplicationTask' }, props);
        }
        DMS.ReplicationTask = ReplicationTask;
    })(DMS = AWS.DMS || (AWS.DMS = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var DataPipeline;
    (function (DataPipeline) {
        /**
         * Creates a data pipeline that you can use to automate the movement and transformation
        of
        data. In each pipeline, you define pipeline objects, such as activities, schedules,
        data nodes,
        and resources. For information about pipeline objects and components that you can
        use, see
        Pipeline Object Reference in the
        AWS Data Pipeline Developer Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-datapipeline-pipeline.html
         */
        function Pipeline(props) {
            return Object.assign({ Type: 'AWS::DataPipeline::Pipeline' }, props);
        }
        DataPipeline.Pipeline = Pipeline;
    })(DataPipeline = AWS.DataPipeline || (AWS.DataPipeline = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var DirectoryService;
    (function (DirectoryService) {
        /**
         * The AWS::DirectoryService::MicrosoftAD resource creates a Microsoft Active
        Directory in AWS so that your directory users and groups can access the AWS Management
        Console and AWS
        applications using their existing credentials. For more information, see What Is AWS Directory Service? in the
        AWS Directory Service Administration Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-directoryservice-microsoftad.html
         */
        function MicrosoftAD(props) {
            return Object.assign({ Type: 'AWS::DirectoryService::MicrosoftAD' }, props);
        }
        DirectoryService.MicrosoftAD = MicrosoftAD;
    })(DirectoryService = AWS.DirectoryService || (AWS.DirectoryService = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var DirectoryService;
    (function (DirectoryService) {
        /**
         * The AWS::DirectoryService::SimpleAD resource creates an AWS Directory Service Simple Active
        Directory (Simple AD) in AWS so that your directory users and groups can access the
        AWS Management Console
        and AWS applications using their existing credentials. Simple AD is a Microsoft Active
        Directory–compatible directory. For more information, see What Is
           AWS Directory Service? in the AWS Directory Service Administration Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-directoryservice-simplead.html
         */
        function SimpleAD(props) {
            return Object.assign({ Type: 'AWS::DirectoryService::SimpleAD' }, props);
        }