cloudformation-declarations/out/declarations/generated/cloudformation-types.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 AmazonMQ;
    (function (AmazonMQ) {
        /**
         * A broker is a message broker environment running on
        Amazon MQ. It is the basic building block of Amazon MQ.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-amazonmq-broker.html
         */
        function Broker(props) {
            return Object.assign({ Type: 'AWS::AmazonMQ::Broker' }, props);
        }
        AmazonMQ.Broker = Broker;
    })(AmazonMQ = AWS.AmazonMQ || (AWS.AmazonMQ = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var AmazonMQ;
    (function (AmazonMQ) {
        /**
         * A configuration contains all of the settings for your
        ActiveMQ broker, in XML format.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-amazonmq-configuration.html
         */
        function Configuration(props) {
            return Object.assign({ Type: 'AWS::AmazonMQ::Configuration' }, props);
        }
        AmazonMQ.Configuration = Configuration;
    })(AmazonMQ = AWS.AmazonMQ || (AWS.AmazonMQ = {}));
})(AWS = exports.AWS || (exports.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 that require 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 ApiGateway;
    (function (ApiGateway) {
        /**
         * The AWS::ApiGateway::VpcLink resource specifies an API Gateway VPC link for a
        AWS::ApiGateway::RestApi to access resources in an Amazon Virtual Private
        Cloud (VPC). For more information, see vpclink:create in the Amazon API Gateway REST API Reference
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-vpclink.html
         */
        function VpcLink(props) {
            return Object.assign({ Type: 'AWS::ApiGateway::VpcLink' }, props);
        }
        ApiGateway.VpcLink = VpcLink;
    })(ApiGateway = AWS.ApiGateway || (AWS.ApiGateway = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var AppSync;
    (function (AppSync) {
        /**
         * The
        AWS::AppSync::ApiKey resource creates a unique key that you can distribute to clients who are executing
        GraphQL operations with AWS AppSync that require an API key.
        
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-appsync-apikey.html
         */
        function ApiKey(props) {
            return Object.assign({ Type: 'AWS::AppSync::ApiKey' }, props);
        }
        AppSync.ApiKey = ApiKey;
    })(AppSync = AWS.AppSync || (AWS.AppSync = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var AppSync;
    (function (AppSync) {
        /**
         * The
        AWS::AppSync::DataSource resource creates data sources for resolvers in AWS AppSync to connect to, such as
        Amazon DynamoDB, AWS Lambda, and Amazon Elasticserach Service.
        Resolvers use these data sources to fetch data when clients make GraphQL calls.
        
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-appsync-datasource.html
         */
        function DataSource(props) {
            return Object.assign({ Type: 'AWS::AppSync::DataSource' }, props);
        }
        AppSync.DataSource = DataSource;
    })(AppSync = AWS.AppSync || (AWS.AppSync = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var AppSync;
    (function (AppSync) {
        /**
         * The
        AWS::AppSync::GraphQLApi resource will create a new AWS AppSync GraphQL API.
        This is the top level construct for your application. For more information see
        Quickstart Guide.
        
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-appsync-graphqlapi.html
         */
        function GraphQLApi(props) {
            return Object.assign({ Type: 'AWS::AppSync::GraphQLApi' }, props);
        }
        AppSync.GraphQLApi = GraphQLApi;
    })(AppSync = AWS.AppSync || (AWS.AppSync = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var AppSync;
    (function (AppSync) {
        /**
         * The
        AWS::AppSync::GraphQLSchema resource is used for your AWS AppSync GraphQL schema which
        controls the data model for your API. Schema files are text written in Schema Definition
        Language (SDL) format.
        You can find information on schema authoring at
        Designing a GraphQL API.
        
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-appsync-graphqlschema.html
         */
        function GraphQLSchema(props) {
            return Object.assign({ Type: 'AWS::AppSync::GraphQLSchema' }, props);
        }
        AppSync.GraphQLSchema = GraphQLSchema;
    })(AppSync = AWS.AppSync || (AWS.AppSync = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var AppSync;
    (function (AppSync) {
        /**
         * The
        AWS::AppSync::Resolver resource defines the logical GraphQL resolver that you will attach to fields in a
        schema.
        Request and Response templates for resolvers are written in Apache Velocity Template
        Language (VTL) format.
        More information on resolvers can be found in the
        Resolver Mapping Template Reference.
        
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-appsync-resolver.html
         */
        function Resolver(props) {
            return Object.assign({ Type: 'AWS::AppSync::Resolver' }, props);
        }
        AppSync.Resolver = Resolver;
    })(AppSync = AWS.AppSync || (AWS.AppSync = {}));
})(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 Athena;
    (function (Athena) {
        /**
         * The
        AWS::Athena::NamedQuery resource creates an Amazon Athena query. For more information, see
        CreateNamedQuery in the
        Amazon Athena Documentation.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-athena-namedquery.html
         */
        function NamedQuery(props) {
            return Object.assign({ Type: 'AWS::Athena::NamedQuery' }, props);
        }
        Athena.NamedQuery = NamedQuery;
    })(Athena = AWS.Athena || (AWS.Athena = {}));
})(AWS = exports.AWS || (exports.AWS = {}));
(function (AWS) {
    var AutoScaling;
    (function (AutoScaling) {
        /**
         * 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) {
        /**
         * Creates an Auto Scaling launch configuration that can be used by an Auto Scaling group
        to configure
        Auto Scaling instances.
     
         *
         * 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) {
        /**
         * Controls 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 Amazon EC2 Auto Scaling Lifecycle Hooks in the Amazon EC2 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) {
        /**
         * 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, see Dynamic Scaling in the Amazon EC2 Auto Scaling User 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 AutoScalingPlans;
    (function (AutoScalingPlans) {
        /**
         * Creates a scaling plan for AWS Auto Scaling. For more information, see the AWS Auto Scaling User Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-autoscalingplans-scalingplan.html
         */
        function ScalingPlan(props) {
            return Object.assign({ Type: 'AWS::AutoScalingPlans::ScalingPlan' }, props);
        }
        AutoScalingPlans.ScalingPlan = ScalingPlan;
    })(AutoScalingPlans = AWS.AutoScalingPlans || (AWS.AutoScalingPlans = {}));
})(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 Budgets;
    (function (Budgets) {
        /**
         * The AWS::Budgets::Budget resource creates, replaces, or deletes budgets for Billing and Cost Management. For
        more
        information, see Managing
           Your Costs with Budgets in the AWS Billing and Cost Management User Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-budgets-budget.html
         */
        function Budget(props) {
            return Object.assign({ Type: 'AWS::Budgets::Budget' }, props);
        }
        Budgets.Budget = Budget;
    })(Budgets = AWS.Budgets || (AWS.Budgets = {}));
})(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 Cloud9;
    (function (Cloud9) {
        /**
         * The AWS::Cloud9::EnvironmentEC2 resource creates an Amazon EC2 development
        environment in AWS Cloud9. For more information, see Creating an
           Environment in the AWS Cloud9 User Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloud9-environmentec2.html
         */
        function EnvironmentEC2(props) {
            return Object.assign({ Type: 'AWS::Cloud9::EnvironmentEC2' }, props);
        }
        Cloud9.EnvironmentEC2 = EnvironmentEC2;
    })(Cloud9 = AWS.Cloud9 || (AWS.Cloud9 = {}));
})(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) {
        /**
         * The AWS::CloudFront::CloudFrontOriginAccessIdentity resource specifies the
        CloudFront origin access identity to associate with the origin of a CloudFront distribution.
        For more
        information, see OriginAccessIdentity in the Amazon CloudFront API Reference.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudfront-cloudfrontoriginaccessidentity.html
         */
        function CloudFrontOriginAccessIdentity(props) {
            return Object.assign({ Type: 'AWS::CloudFront::CloudFrontOriginAccessIdentity' }, props);
        }
        CloudFront.CloudFrontOriginAccessIdentity = CloudFrontOriginAccessIdentity;
    })(CloudFront = AWS.CloudFront || (AWS.CloudFront = {}));
})(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-resource-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 CloudFront;
    (function (CloudFront) {
        /**
         * The AWS::CloudFront::StreamingDistribution resource specifies an RMTP
        distribution for Amazon CloudFront. An RTMP distribution is similar to a web distribution,
        but an RTMP
        distribution streams media files using the Adobe Real-Time Messaging Protocol (RTMP)
        instead of
        serving files using HTTP. For more information, see CreateStreamingDistribution in
        the Amazon CloudFront API Reference.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudfront-streamingdistribution.html
         */
        function StreamingDistribution(props) {
            return Object.assign({ Type: 'AWS::CloudFront::StreamingDistribution' }, props);
        }
        CloudFront.StreamingDistribution = StreamingDistribution;
    })(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 CodePipeline;
    (function (CodePipeline) {
        /**
         * The AWS::CodePipeline::Webhook resource creates and registers your webhook.
        After the webhook is created and registered, it triggers your pipeline to start every
        time an
        external event occurs. For more information, see Configure Your GitHub Pipelines to Use
           Webhooks for Change Detection in the AWS CodePipeline User Guide.
     
         *
         * Documentation: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-webhook.html
         */
        function Webhook(props) {
            return Object.assign({ Type: 'AWS::CodePipeline::Webhook' }, props);
        }
        CodePipeline.Webhook = Webhook;
    })(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. For more information on working
        with Amazon Cognito user pools, see Amazon Cognito User
           Pools and CreateUserPool.
     
         *
         * 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 = {}