'use strict';

var client$1 = require('@aws-sdk/core/client');
var core = require('@smithy/core');
var client = require('@smithy/core/client');
var config = require('@smithy/core/config');
var endpoints = require('@smithy/core/endpoints');
var protocols = require('@smithy/core/protocols');
var retry = require('@smithy/core/retry');
var schema = require('@smithy/core/schema');
var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
var runtimeConfig = require('./runtimeConfig');
var schemas_0 = require('./schemas/schemas_0');
var errors = require('./models/errors');
var CloudFormationServiceException = require('./models/CloudFormationServiceException');

const resolveClientEndpointParameters = (options) => {
    return Object.assign(options, {
        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
        useFipsEndpoint: options.useFipsEndpoint ?? false,
        defaultSigningName: "cloudformation",
    });
};
const commonParams = {
    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
    Endpoint: { type: "builtInParams", name: "endpoint" },
    Region: { type: "builtInParams", name: "region" },
    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
};

const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
    let _credentials = runtimeConfig.credentials;
    return {
        setHttpAuthScheme(httpAuthScheme) {
            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
            if (index === -1) {
                _httpAuthSchemes.push(httpAuthScheme);
            }
            else {
                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
            }
        },
        httpAuthSchemes() {
            return _httpAuthSchemes;
        },
        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
            _httpAuthSchemeProvider = httpAuthSchemeProvider;
        },
        httpAuthSchemeProvider() {
            return _httpAuthSchemeProvider;
        },
        setCredentials(credentials) {
            _credentials = credentials;
        },
        credentials() {
            return _credentials;
        },
    };
};
const resolveHttpAuthRuntimeConfig = (config) => {
    return {
        httpAuthSchemes: config.httpAuthSchemes(),
        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
        credentials: config.credentials(),
    };
};

const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
    const extensionConfiguration = Object.assign(client$1.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
    extensions.forEach((extension) => extension.configure(extensionConfiguration));
    return Object.assign(runtimeConfig, client$1.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
};

class CloudFormationClient extends client.Client {
    config;
    constructor(...[configuration]) {
        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
        super(_config_0);
        this.initConfig = _config_0;
        const _config_1 = resolveClientEndpointParameters(_config_0);
        const _config_2 = client$1.resolveUserAgentConfig(_config_1);
        const _config_3 = retry.resolveRetryConfig(_config_2);
        const _config_4 = config.resolveRegionConfig(_config_3);
        const _config_5 = client$1.resolveHostHeaderConfig(_config_4);
        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
        const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
        this.config = _config_8;
        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
        this.middlewareStack.use(client$1.getUserAgentPlugin(this.config));
        this.middlewareStack.use(retry.getRetryPlugin(this.config));
        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
        this.middlewareStack.use(client$1.getHostHeaderPlugin(this.config));
        this.middlewareStack.use(client$1.getLoggerPlugin(this.config));
        this.middlewareStack.use(client$1.getRecursionDetectionPlugin(this.config));
        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultCloudFormationHttpAuthSchemeParametersProvider,
            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
                "aws.auth#sigv4": config.credentials,
            }),
        }));
        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
    }
    destroy() {
        super.destroy();
    }
}

class ActivateOrganizationsAccessCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ActivateOrganizationsAccess", {})
    .n("CloudFormationClient", "ActivateOrganizationsAccessCommand")
    .sc(schemas_0.ActivateOrganizationsAccess$)
    .build() {
}

class ActivateTypeCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ActivateType", {})
    .n("CloudFormationClient", "ActivateTypeCommand")
    .sc(schemas_0.ActivateType$)
    .build() {
}

class BatchDescribeTypeConfigurationsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "BatchDescribeTypeConfigurations", {})
    .n("CloudFormationClient", "BatchDescribeTypeConfigurationsCommand")
    .sc(schemas_0.BatchDescribeTypeConfigurations$)
    .build() {
}

class CancelUpdateStackCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "CancelUpdateStack", {})
    .n("CloudFormationClient", "CancelUpdateStackCommand")
    .sc(schemas_0.CancelUpdateStack$)
    .build() {
}

class ContinueUpdateRollbackCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ContinueUpdateRollback", {})
    .n("CloudFormationClient", "ContinueUpdateRollbackCommand")
    .sc(schemas_0.ContinueUpdateRollback$)
    .build() {
}

class CreateChangeSetCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "CreateChangeSet", {})
    .n("CloudFormationClient", "CreateChangeSetCommand")
    .sc(schemas_0.CreateChangeSet$)
    .build() {
}

class CreateGeneratedTemplateCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "CreateGeneratedTemplate", {})
    .n("CloudFormationClient", "CreateGeneratedTemplateCommand")
    .sc(schemas_0.CreateGeneratedTemplate$)
    .build() {
}

class CreateStackCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "CreateStack", {})
    .n("CloudFormationClient", "CreateStackCommand")
    .sc(schemas_0.CreateStack$)
    .build() {
}

class CreateStackInstancesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "CreateStackInstances", {})
    .n("CloudFormationClient", "CreateStackInstancesCommand")
    .sc(schemas_0.CreateStackInstances$)
    .build() {
}

class CreateStackRefactorCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "CreateStackRefactor", {})
    .n("CloudFormationClient", "CreateStackRefactorCommand")
    .sc(schemas_0.CreateStackRefactor$)
    .build() {
}

class CreateStackSetCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "CreateStackSet", {})
    .n("CloudFormationClient", "CreateStackSetCommand")
    .sc(schemas_0.CreateStackSet$)
    .build() {
}

class DeactivateOrganizationsAccessCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DeactivateOrganizationsAccess", {})
    .n("CloudFormationClient", "DeactivateOrganizationsAccessCommand")
    .sc(schemas_0.DeactivateOrganizationsAccess$)
    .build() {
}

class DeactivateTypeCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DeactivateType", {})
    .n("CloudFormationClient", "DeactivateTypeCommand")
    .sc(schemas_0.DeactivateType$)
    .build() {
}

class DeleteChangeSetCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DeleteChangeSet", {})
    .n("CloudFormationClient", "DeleteChangeSetCommand")
    .sc(schemas_0.DeleteChangeSet$)
    .build() {
}

class DeleteGeneratedTemplateCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DeleteGeneratedTemplate", {})
    .n("CloudFormationClient", "DeleteGeneratedTemplateCommand")
    .sc(schemas_0.DeleteGeneratedTemplate$)
    .build() {
}

class DeleteStackCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DeleteStack", {})
    .n("CloudFormationClient", "DeleteStackCommand")
    .sc(schemas_0.DeleteStack$)
    .build() {
}

class DeleteStackInstancesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DeleteStackInstances", {})
    .n("CloudFormationClient", "DeleteStackInstancesCommand")
    .sc(schemas_0.DeleteStackInstances$)
    .build() {
}

class DeleteStackSetCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DeleteStackSet", {})
    .n("CloudFormationClient", "DeleteStackSetCommand")
    .sc(schemas_0.DeleteStackSet$)
    .build() {
}

class DeregisterTypeCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DeregisterType", {})
    .n("CloudFormationClient", "DeregisterTypeCommand")
    .sc(schemas_0.DeregisterType$)
    .build() {
}

class DescribeAccountLimitsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeAccountLimits", {})
    .n("CloudFormationClient", "DescribeAccountLimitsCommand")
    .sc(schemas_0.DescribeAccountLimits$)
    .build() {
}

class DescribeChangeSetCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeChangeSet", {})
    .n("CloudFormationClient", "DescribeChangeSetCommand")
    .sc(schemas_0.DescribeChangeSet$)
    .build() {
}

class DescribeChangeSetHooksCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeChangeSetHooks", {})
    .n("CloudFormationClient", "DescribeChangeSetHooksCommand")
    .sc(schemas_0.DescribeChangeSetHooks$)
    .build() {
}

class DescribeEventsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeEvents", {})
    .n("CloudFormationClient", "DescribeEventsCommand")
    .sc(schemas_0.DescribeEvents$)
    .build() {
}

class DescribeGeneratedTemplateCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeGeneratedTemplate", {})
    .n("CloudFormationClient", "DescribeGeneratedTemplateCommand")
    .sc(schemas_0.DescribeGeneratedTemplate$)
    .build() {
}

class DescribeOrganizationsAccessCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeOrganizationsAccess", {})
    .n("CloudFormationClient", "DescribeOrganizationsAccessCommand")
    .sc(schemas_0.DescribeOrganizationsAccess$)
    .build() {
}

class DescribePublisherCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribePublisher", {})
    .n("CloudFormationClient", "DescribePublisherCommand")
    .sc(schemas_0.DescribePublisher$)
    .build() {
}

class DescribeResourceScanCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeResourceScan", {})
    .n("CloudFormationClient", "DescribeResourceScanCommand")
    .sc(schemas_0.DescribeResourceScan$)
    .build() {
}

class DescribeStackDriftDetectionStatusCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeStackDriftDetectionStatus", {})
    .n("CloudFormationClient", "DescribeStackDriftDetectionStatusCommand")
    .sc(schemas_0.DescribeStackDriftDetectionStatus$)
    .build() {
}

class DescribeStackEventsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeStackEvents", {})
    .n("CloudFormationClient", "DescribeStackEventsCommand")
    .sc(schemas_0.DescribeStackEvents$)
    .build() {
}

class DescribeStackInstanceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeStackInstance", {})
    .n("CloudFormationClient", "DescribeStackInstanceCommand")
    .sc(schemas_0.DescribeStackInstance$)
    .build() {
}

class DescribeStackRefactorCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeStackRefactor", {})
    .n("CloudFormationClient", "DescribeStackRefactorCommand")
    .sc(schemas_0.DescribeStackRefactor$)
    .build() {
}

class DescribeStackResourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeStackResource", {})
    .n("CloudFormationClient", "DescribeStackResourceCommand")
    .sc(schemas_0.DescribeStackResource$)
    .build() {
}

class DescribeStackResourceDriftsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeStackResourceDrifts", {})
    .n("CloudFormationClient", "DescribeStackResourceDriftsCommand")
    .sc(schemas_0.DescribeStackResourceDrifts$)
    .build() {
}

class DescribeStackResourcesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeStackResources", {})
    .n("CloudFormationClient", "DescribeStackResourcesCommand")
    .sc(schemas_0.DescribeStackResources$)
    .build() {
}

class DescribeStacksCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeStacks", {})
    .n("CloudFormationClient", "DescribeStacksCommand")
    .sc(schemas_0.DescribeStacks$)
    .build() {
}

class DescribeStackSetCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeStackSet", {})
    .n("CloudFormationClient", "DescribeStackSetCommand")
    .sc(schemas_0.DescribeStackSet$)
    .build() {
}

class DescribeStackSetOperationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeStackSetOperation", {})
    .n("CloudFormationClient", "DescribeStackSetOperationCommand")
    .sc(schemas_0.DescribeStackSetOperation$)
    .build() {
}

class DescribeTypeCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeType", {})
    .n("CloudFormationClient", "DescribeTypeCommand")
    .sc(schemas_0.DescribeType$)
    .build() {
}

class DescribeTypeRegistrationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DescribeTypeRegistration", {})
    .n("CloudFormationClient", "DescribeTypeRegistrationCommand")
    .sc(schemas_0.DescribeTypeRegistration$)
    .build() {
}

class DetectStackDriftCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DetectStackDrift", {})
    .n("CloudFormationClient", "DetectStackDriftCommand")
    .sc(schemas_0.DetectStackDrift$)
    .build() {
}

class DetectStackResourceDriftCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DetectStackResourceDrift", {})
    .n("CloudFormationClient", "DetectStackResourceDriftCommand")
    .sc(schemas_0.DetectStackResourceDrift$)
    .build() {
}

class DetectStackSetDriftCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "DetectStackSetDrift", {})
    .n("CloudFormationClient", "DetectStackSetDriftCommand")
    .sc(schemas_0.DetectStackSetDrift$)
    .build() {
}

class EstimateTemplateCostCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "EstimateTemplateCost", {})
    .n("CloudFormationClient", "EstimateTemplateCostCommand")
    .sc(schemas_0.EstimateTemplateCost$)
    .build() {
}

class ExecuteChangeSetCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ExecuteChangeSet", {})
    .n("CloudFormationClient", "ExecuteChangeSetCommand")
    .sc(schemas_0.ExecuteChangeSet$)
    .build() {
}

class ExecuteStackRefactorCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ExecuteStackRefactor", {})
    .n("CloudFormationClient", "ExecuteStackRefactorCommand")
    .sc(schemas_0.ExecuteStackRefactor$)
    .build() {
}

class GetGeneratedTemplateCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "GetGeneratedTemplate", {})
    .n("CloudFormationClient", "GetGeneratedTemplateCommand")
    .sc(schemas_0.GetGeneratedTemplate$)
    .build() {
}

class GetHookResultCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "GetHookResult", {})
    .n("CloudFormationClient", "GetHookResultCommand")
    .sc(schemas_0.GetHookResult$)
    .build() {
}

class GetStackPolicyCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "GetStackPolicy", {})
    .n("CloudFormationClient", "GetStackPolicyCommand")
    .sc(schemas_0.GetStackPolicy$)
    .build() {
}

class GetTemplateCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "GetTemplate", {})
    .n("CloudFormationClient", "GetTemplateCommand")
    .sc(schemas_0.GetTemplate$)
    .build() {
}

class GetTemplateSummaryCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "GetTemplateSummary", {})
    .n("CloudFormationClient", "GetTemplateSummaryCommand")
    .sc(schemas_0.GetTemplateSummary$)
    .build() {
}

class ImportStacksToStackSetCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ImportStacksToStackSet", {})
    .n("CloudFormationClient", "ImportStacksToStackSetCommand")
    .sc(schemas_0.ImportStacksToStackSet$)
    .build() {
}

class ListChangeSetsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListChangeSets", {})
    .n("CloudFormationClient", "ListChangeSetsCommand")
    .sc(schemas_0.ListChangeSets$)
    .build() {
}

class ListExportsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListExports", {})
    .n("CloudFormationClient", "ListExportsCommand")
    .sc(schemas_0.ListExports$)
    .build() {
}

class ListGeneratedTemplatesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListGeneratedTemplates", {})
    .n("CloudFormationClient", "ListGeneratedTemplatesCommand")
    .sc(schemas_0.ListGeneratedTemplates$)
    .build() {
}

class ListHookResultsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListHookResults", {})
    .n("CloudFormationClient", "ListHookResultsCommand")
    .sc(schemas_0.ListHookResults$)
    .build() {
}

class ListImportsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListImports", {})
    .n("CloudFormationClient", "ListImportsCommand")
    .sc(schemas_0.ListImports$)
    .build() {
}

class ListResourceScanRelatedResourcesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListResourceScanRelatedResources", {})
    .n("CloudFormationClient", "ListResourceScanRelatedResourcesCommand")
    .sc(schemas_0.ListResourceScanRelatedResources$)
    .build() {
}

class ListResourceScanResourcesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListResourceScanResources", {})
    .n("CloudFormationClient", "ListResourceScanResourcesCommand")
    .sc(schemas_0.ListResourceScanResources$)
    .build() {
}

class ListResourceScansCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListResourceScans", {})
    .n("CloudFormationClient", "ListResourceScansCommand")
    .sc(schemas_0.ListResourceScans$)
    .build() {
}

class ListStackInstanceResourceDriftsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListStackInstanceResourceDrifts", {})
    .n("CloudFormationClient", "ListStackInstanceResourceDriftsCommand")
    .sc(schemas_0.ListStackInstanceResourceDrifts$)
    .build() {
}

class ListStackInstancesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListStackInstances", {})
    .n("CloudFormationClient", "ListStackInstancesCommand")
    .sc(schemas_0.ListStackInstances$)
    .build() {
}

class ListStackRefactorActionsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListStackRefactorActions", {})
    .n("CloudFormationClient", "ListStackRefactorActionsCommand")
    .sc(schemas_0.ListStackRefactorActions$)
    .build() {
}

class ListStackRefactorsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListStackRefactors", {})
    .n("CloudFormationClient", "ListStackRefactorsCommand")
    .sc(schemas_0.ListStackRefactors$)
    .build() {
}

class ListStackResourcesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListStackResources", {})
    .n("CloudFormationClient", "ListStackResourcesCommand")
    .sc(schemas_0.ListStackResources$)
    .build() {
}

class ListStacksCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListStacks", {})
    .n("CloudFormationClient", "ListStacksCommand")
    .sc(schemas_0.ListStacks$)
    .build() {
}

class ListStackSetAutoDeploymentTargetsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListStackSetAutoDeploymentTargets", {})
    .n("CloudFormationClient", "ListStackSetAutoDeploymentTargetsCommand")
    .sc(schemas_0.ListStackSetAutoDeploymentTargets$)
    .build() {
}

class ListStackSetOperationResultsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListStackSetOperationResults", {})
    .n("CloudFormationClient", "ListStackSetOperationResultsCommand")
    .sc(schemas_0.ListStackSetOperationResults$)
    .build() {
}

class ListStackSetOperationsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListStackSetOperations", {})
    .n("CloudFormationClient", "ListStackSetOperationsCommand")
    .sc(schemas_0.ListStackSetOperations$)
    .build() {
}

class ListStackSetsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListStackSets", {})
    .n("CloudFormationClient", "ListStackSetsCommand")
    .sc(schemas_0.ListStackSets$)
    .build() {
}

class ListTypeRegistrationsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListTypeRegistrations", {})
    .n("CloudFormationClient", "ListTypeRegistrationsCommand")
    .sc(schemas_0.ListTypeRegistrations$)
    .build() {
}

class ListTypesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListTypes", {})
    .n("CloudFormationClient", "ListTypesCommand")
    .sc(schemas_0.ListTypes$)
    .build() {
}

class ListTypeVersionsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ListTypeVersions", {})
    .n("CloudFormationClient", "ListTypeVersionsCommand")
    .sc(schemas_0.ListTypeVersions$)
    .build() {
}

class PublishTypeCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "PublishType", {})
    .n("CloudFormationClient", "PublishTypeCommand")
    .sc(schemas_0.PublishType$)
    .build() {
}

class RecordHandlerProgressCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "RecordHandlerProgress", {})
    .n("CloudFormationClient", "RecordHandlerProgressCommand")
    .sc(schemas_0.RecordHandlerProgress$)
    .build() {
}

class RegisterPublisherCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "RegisterPublisher", {})
    .n("CloudFormationClient", "RegisterPublisherCommand")
    .sc(schemas_0.RegisterPublisher$)
    .build() {
}

class RegisterTypeCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "RegisterType", {})
    .n("CloudFormationClient", "RegisterTypeCommand")
    .sc(schemas_0.RegisterType$)
    .build() {
}

class RollbackStackCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "RollbackStack", {})
    .n("CloudFormationClient", "RollbackStackCommand")
    .sc(schemas_0.RollbackStack$)
    .build() {
}

class SetStackPolicyCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "SetStackPolicy", {})
    .n("CloudFormationClient", "SetStackPolicyCommand")
    .sc(schemas_0.SetStackPolicy$)
    .build() {
}

class SetTypeConfigurationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "SetTypeConfiguration", {})
    .n("CloudFormationClient", "SetTypeConfigurationCommand")
    .sc(schemas_0.SetTypeConfiguration$)
    .build() {
}

class SetTypeDefaultVersionCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "SetTypeDefaultVersion", {})
    .n("CloudFormationClient", "SetTypeDefaultVersionCommand")
    .sc(schemas_0.SetTypeDefaultVersion$)
    .build() {
}

class SignalResourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "SignalResource", {})
    .n("CloudFormationClient", "SignalResourceCommand")
    .sc(schemas_0.SignalResource$)
    .build() {
}

class StartResourceScanCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "StartResourceScan", {})
    .n("CloudFormationClient", "StartResourceScanCommand")
    .sc(schemas_0.StartResourceScan$)
    .build() {
}

class StopStackSetOperationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "StopStackSetOperation", {})
    .n("CloudFormationClient", "StopStackSetOperationCommand")
    .sc(schemas_0.StopStackSetOperation$)
    .build() {
}

class TestTypeCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "TestType", {})
    .n("CloudFormationClient", "TestTypeCommand")
    .sc(schemas_0.TestType$)
    .build() {
}

class UpdateGeneratedTemplateCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "UpdateGeneratedTemplate", {})
    .n("CloudFormationClient", "UpdateGeneratedTemplateCommand")
    .sc(schemas_0.UpdateGeneratedTemplate$)
    .build() {
}

class UpdateStackCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "UpdateStack", {})
    .n("CloudFormationClient", "UpdateStackCommand")
    .sc(schemas_0.UpdateStack$)
    .build() {
}

class UpdateStackInstancesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "UpdateStackInstances", {})
    .n("CloudFormationClient", "UpdateStackInstancesCommand")
    .sc(schemas_0.UpdateStackInstances$)
    .build() {
}

class UpdateStackSetCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "UpdateStackSet", {})
    .n("CloudFormationClient", "UpdateStackSetCommand")
    .sc(schemas_0.UpdateStackSet$)
    .build() {
}

class UpdateTerminationProtectionCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "UpdateTerminationProtection", {})
    .n("CloudFormationClient", "UpdateTerminationProtectionCommand")
    .sc(schemas_0.UpdateTerminationProtection$)
    .build() {
}

class ValidateTemplateCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ValidateTemplate", {})
    .n("CloudFormationClient", "ValidateTemplateCommand")
    .sc(schemas_0.ValidateTemplate$)
    .build() {
}

const paginateDescribeAccountLimits = core.createPaginator(CloudFormationClient, DescribeAccountLimitsCommand, "NextToken", "NextToken", "");

const paginateDescribeChangeSet = core.createPaginator(CloudFormationClient, DescribeChangeSetCommand, "NextToken", "NextToken", "");

const paginateDescribeEvents = core.createPaginator(CloudFormationClient, DescribeEventsCommand, "NextToken", "NextToken", "");

const paginateDescribeStackEvents = core.createPaginator(CloudFormationClient, DescribeStackEventsCommand, "NextToken", "NextToken", "");

const paginateDescribeStackResourceDrifts = core.createPaginator(CloudFormationClient, DescribeStackResourceDriftsCommand, "NextToken", "NextToken", "MaxResults");

const paginateDescribeStacks = core.createPaginator(CloudFormationClient, DescribeStacksCommand, "NextToken", "NextToken", "");

const paginateListChangeSets = core.createPaginator(CloudFormationClient, ListChangeSetsCommand, "NextToken", "NextToken", "");

const paginateListExports = core.createPaginator(CloudFormationClient, ListExportsCommand, "NextToken", "NextToken", "");

const paginateListGeneratedTemplates = core.createPaginator(CloudFormationClient, ListGeneratedTemplatesCommand, "NextToken", "NextToken", "MaxResults");

const paginateListImports = core.createPaginator(CloudFormationClient, ListImportsCommand, "NextToken", "NextToken", "");

const paginateListResourceScanRelatedResources = core.createPaginator(CloudFormationClient, ListResourceScanRelatedResourcesCommand, "NextToken", "NextToken", "MaxResults");

const paginateListResourceScanResources = core.createPaginator(CloudFormationClient, ListResourceScanResourcesCommand, "NextToken", "NextToken", "MaxResults");

const paginateListResourceScans = core.createPaginator(CloudFormationClient, ListResourceScansCommand, "NextToken", "NextToken", "MaxResults");

const paginateListStackInstances = core.createPaginator(CloudFormationClient, ListStackInstancesCommand, "NextToken", "NextToken", "MaxResults");

const paginateListStackRefactorActions = core.createPaginator(CloudFormationClient, ListStackRefactorActionsCommand, "NextToken", "NextToken", "MaxResults");

const paginateListStackRefactors = core.createPaginator(CloudFormationClient, ListStackRefactorsCommand, "NextToken", "NextToken", "MaxResults");

const paginateListStackResources = core.createPaginator(CloudFormationClient, ListStackResourcesCommand, "NextToken", "NextToken", "");

const paginateListStackSetOperationResults = core.createPaginator(CloudFormationClient, ListStackSetOperationResultsCommand, "NextToken", "NextToken", "MaxResults");

const paginateListStackSetOperations = core.createPaginator(CloudFormationClient, ListStackSetOperationsCommand, "NextToken", "NextToken", "MaxResults");

const paginateListStackSets = core.createPaginator(CloudFormationClient, ListStackSetsCommand, "NextToken", "NextToken", "MaxResults");

const paginateListStacks = core.createPaginator(CloudFormationClient, ListStacksCommand, "NextToken", "NextToken", "");

const paginateListTypeRegistrations = core.createPaginator(CloudFormationClient, ListTypeRegistrationsCommand, "NextToken", "NextToken", "MaxResults");

const paginateListTypes = core.createPaginator(CloudFormationClient, ListTypesCommand, "NextToken", "NextToken", "MaxResults");

const paginateListTypeVersions = core.createPaginator(CloudFormationClient, ListTypeVersionsCommand, "NextToken", "NextToken", "MaxResults");

const checkState$9 = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeChangeSetCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.Status;
            };
            if (returnComparator() === "CREATE_COMPLETE") {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.Status;
            };
            if (returnComparator() === "FAILED") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
        if (exception.name === "ValidationError") {
            return { state: client.WaiterState.FAILURE, reason };
        }
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForChangeSetCreateComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
};
const waitUntilChangeSetCreateComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
    return client.checkExceptions(result);
};

const checkState$8 = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeStacksCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            let allStringEq_5 = (returnComparator().length > 0);
            for (let element_4 of returnComparator()) {
                allStringEq_5 = allStringEq_5 && (element_4 == "CREATE_COMPLETE");
            }
            if (allStringEq_5) {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            let allStringEq_5 = (returnComparator().length > 0);
            for (let element_4 of returnComparator()) {
                allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_COMPLETE");
            }
            if (allStringEq_5) {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            let allStringEq_5 = (returnComparator().length > 0);
            for (let element_4 of returnComparator()) {
                allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_IN_PROGRESS");
            }
            if (allStringEq_5) {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            let allStringEq_5 = (returnComparator().length > 0);
            for (let element_4 of returnComparator()) {
                allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS");
            }
            if (allStringEq_5) {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            let allStringEq_5 = (returnComparator().length > 0);
            for (let element_4 of returnComparator()) {
                allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_FAILED");
            }
            if (allStringEq_5) {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            let allStringEq_5 = (returnComparator().length > 0);
            for (let element_4 of returnComparator()) {
                allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_ROLLBACK_IN_PROGRESS");
            }
            if (allStringEq_5) {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            let allStringEq_5 = (returnComparator().length > 0);
            for (let element_4 of returnComparator()) {
                allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_ROLLBACK_FAILED");
            }
            if (allStringEq_5) {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            let allStringEq_5 = (returnComparator().length > 0);
            for (let element_4 of returnComparator()) {
                allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS");
            }
            if (allStringEq_5) {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            let allStringEq_5 = (returnComparator().length > 0);
            for (let element_4 of returnComparator()) {
                allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_ROLLBACK_COMPLETE");
            }
            if (allStringEq_5) {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "CREATE_FAILED") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "DELETE_COMPLETE") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "DELETE_FAILED") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "ROLLBACK_FAILED") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "ROLLBACK_COMPLETE") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
        if (exception.name === "ValidationError") {
            return { state: client.WaiterState.FAILURE, reason };
        }
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForStackCreateComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
};
const waitUntilStackCreateComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
    return client.checkExceptions(result);
};

const checkState$7 = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeStacksCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            let allStringEq_5 = (returnComparator().length > 0);
            for (let element_4 of returnComparator()) {
                allStringEq_5 = allStringEq_5 && (element_4 == "DELETE_COMPLETE");
            }
            if (allStringEq_5) {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "DELETE_FAILED") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "CREATE_FAILED") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "ROLLBACK_FAILED") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "UPDATE_ROLLBACK_IN_PROGRESS") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "UPDATE_ROLLBACK_FAILED") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "UPDATE_ROLLBACK_COMPLETE") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "UPDATE_COMPLETE") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
        if (exception.name === "ValidationError") {
            return { state: client.WaiterState.SUCCESS, reason };
        }
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForStackDeleteComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
};
const waitUntilStackDeleteComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
    return client.checkExceptions(result);
};

const checkState$6 = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeStacksCommand(input));
        reason = result;
        return { state: client.WaiterState.SUCCESS, reason };
    }
    catch (exception) {
        reason = exception;
        if (exception.name === "ValidationError") {
            return { state: client.WaiterState.RETRY, reason };
        }
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForStackExists = async (params, input) => {
    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
};
const waitUntilStackExists = async (params, input) => {
    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
    return client.checkExceptions(result);
};

const checkState$5 = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeStacksCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            let allStringEq_5 = (returnComparator().length > 0);
            for (let element_4 of returnComparator()) {
                allStringEq_5 = allStringEq_5 && (element_4 == "IMPORT_COMPLETE");
            }
            if (allStringEq_5) {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "ROLLBACK_COMPLETE") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "ROLLBACK_FAILED") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "IMPORT_ROLLBACK_IN_PROGRESS") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "IMPORT_ROLLBACK_FAILED") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "IMPORT_ROLLBACK_COMPLETE") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
        if (exception.name === "ValidationError") {
            return { state: client.WaiterState.FAILURE, reason };
        }
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForStackImportComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
};
const waitUntilStackImportComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
    return client.checkExceptions(result);
};

const checkState$4 = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeStackRefactorCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.Status;
            };
            if (returnComparator() === "CREATE_COMPLETE") {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.Status;
            };
            if (returnComparator() === "CREATE_FAILED") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
        if (exception.name === "ValidationError") {
            return { state: client.WaiterState.FAILURE, reason };
        }
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForStackRefactorCreateComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
};
const waitUntilStackRefactorCreateComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
    return client.checkExceptions(result);
};

const checkState$3 = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeStackRefactorCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.ExecutionStatus;
            };
            if (returnComparator() === "EXECUTE_COMPLETE") {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.ExecutionStatus;
            };
            if (returnComparator() === "EXECUTE_FAILED") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.ExecutionStatus;
            };
            if (returnComparator() === "ROLLBACK_COMPLETE") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
        if (exception.name === "ValidationError") {
            return { state: client.WaiterState.FAILURE, reason };
        }
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForStackRefactorExecuteComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
};
const waitUntilStackRefactorExecuteComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
    return client.checkExceptions(result);
};

const checkState$2 = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeStacksCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            let allStringEq_5 = (returnComparator().length > 0);
            for (let element_4 of returnComparator()) {
                allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_ROLLBACK_COMPLETE");
            }
            if (allStringEq_5) {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "UPDATE_FAILED") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "UPDATE_ROLLBACK_FAILED") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "DELETE_FAILED") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
        if (exception.name === "ValidationError") {
            return { state: client.WaiterState.FAILURE, reason };
        }
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForStackRollbackComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
};
const waitUntilStackRollbackComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
    return client.checkExceptions(result);
};

const checkState$1 = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeStacksCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            let allStringEq_5 = (returnComparator().length > 0);
            for (let element_4 of returnComparator()) {
                allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_COMPLETE");
            }
            if (allStringEq_5) {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "UPDATE_FAILED") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "UPDATE_ROLLBACK_FAILED") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    return element_2.StackStatus;
                });
                return projection_3;
            };
            for (let anyStringEq_4 of returnComparator()) {
                if (anyStringEq_4 == "UPDATE_ROLLBACK_COMPLETE") {
                    return { state: client.WaiterState.FAILURE, reason };
                }
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
        if (exception.name === "ValidationError") {
            return { state: client.WaiterState.FAILURE, reason };
        }
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForStackUpdateComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
};
const waitUntilStackUpdateComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
    return client.checkExceptions(result);
};

const checkState = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeTypeRegistrationCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.ProgressStatus;
            };
            if (returnComparator() === "COMPLETE") {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.ProgressStatus;
            };
            if (returnComparator() === "FAILED") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForTypeRegistrationComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
};
const waitUntilTypeRegistrationComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
    return client.checkExceptions(result);
};

const commands = {
    ActivateOrganizationsAccessCommand,
    ActivateTypeCommand,
    BatchDescribeTypeConfigurationsCommand,
    CancelUpdateStackCommand,
    ContinueUpdateRollbackCommand,
    CreateChangeSetCommand,
    CreateGeneratedTemplateCommand,
    CreateStackCommand,
    CreateStackInstancesCommand,
    CreateStackRefactorCommand,
    CreateStackSetCommand,
    DeactivateOrganizationsAccessCommand,
    DeactivateTypeCommand,
    DeleteChangeSetCommand,
    DeleteGeneratedTemplateCommand,
    DeleteStackCommand,
    DeleteStackInstancesCommand,
    DeleteStackSetCommand,
    DeregisterTypeCommand,
    DescribeAccountLimitsCommand,
    DescribeChangeSetCommand,
    DescribeChangeSetHooksCommand,
    DescribeEventsCommand,
    DescribeGeneratedTemplateCommand,
    DescribeOrganizationsAccessCommand,
    DescribePublisherCommand,
    DescribeResourceScanCommand,
    DescribeStackDriftDetectionStatusCommand,
    DescribeStackEventsCommand,
    DescribeStackInstanceCommand,
    DescribeStackRefactorCommand,
    DescribeStackResourceCommand,
    DescribeStackResourceDriftsCommand,
    DescribeStackResourcesCommand,
    DescribeStacksCommand,
    DescribeStackSetCommand,
    DescribeStackSetOperationCommand,
    DescribeTypeCommand,
    DescribeTypeRegistrationCommand,
    DetectStackDriftCommand,
    DetectStackResourceDriftCommand,
    DetectStackSetDriftCommand,
    EstimateTemplateCostCommand,
    ExecuteChangeSetCommand,
    ExecuteStackRefactorCommand,
    GetGeneratedTemplateCommand,
    GetHookResultCommand,
    GetStackPolicyCommand,
    GetTemplateCommand,
    GetTemplateSummaryCommand,
    ImportStacksToStackSetCommand,
    ListChangeSetsCommand,
    ListExportsCommand,
    ListGeneratedTemplatesCommand,
    ListHookResultsCommand,
    ListImportsCommand,
    ListResourceScanRelatedResourcesCommand,
    ListResourceScanResourcesCommand,
    ListResourceScansCommand,
    ListStackInstanceResourceDriftsCommand,
    ListStackInstancesCommand,
    ListStackRefactorActionsCommand,
    ListStackRefactorsCommand,
    ListStackResourcesCommand,
    ListStacksCommand,
    ListStackSetAutoDeploymentTargetsCommand,
    ListStackSetOperationResultsCommand,
    ListStackSetOperationsCommand,
    ListStackSetsCommand,
    ListTypeRegistrationsCommand,
    ListTypesCommand,
    ListTypeVersionsCommand,
    PublishTypeCommand,
    RecordHandlerProgressCommand,
    RegisterPublisherCommand,
    RegisterTypeCommand,
    RollbackStackCommand,
    SetStackPolicyCommand,
    SetTypeConfigurationCommand,
    SetTypeDefaultVersionCommand,
    SignalResourceCommand,
    StartResourceScanCommand,
    StopStackSetOperationCommand,
    TestTypeCommand,
    UpdateGeneratedTemplateCommand,
    UpdateStackCommand,
    UpdateStackInstancesCommand,
    UpdateStackSetCommand,
    UpdateTerminationProtectionCommand,
    ValidateTemplateCommand,
};
const paginators = {
    paginateDescribeAccountLimits,
    paginateDescribeChangeSet,
    paginateDescribeEvents,
    paginateDescribeStackEvents,
    paginateDescribeStackResourceDrifts,
    paginateDescribeStacks,
    paginateListChangeSets,
    paginateListExports,
    paginateListGeneratedTemplates,
    paginateListImports,
    paginateListResourceScanRelatedResources,
    paginateListResourceScanResources,
    paginateListResourceScans,
    paginateListStackInstances,
    paginateListStackRefactorActions,
    paginateListStackRefactors,
    paginateListStackResources,
    paginateListStacks,
    paginateListStackSetOperationResults,
    paginateListStackSetOperations,
    paginateListStackSets,
    paginateListTypeRegistrations,
    paginateListTypes,
    paginateListTypeVersions,
};
const waiters = {
    waitUntilChangeSetCreateComplete,
    waitUntilStackRefactorCreateComplete,
    waitUntilStackRefactorExecuteComplete,
    waitUntilStackCreateComplete,
    waitUntilStackDeleteComplete,
    waitUntilStackExists,
    waitUntilStackImportComplete,
    waitUntilStackRollbackComplete,
    waitUntilStackUpdateComplete,
    waitUntilTypeRegistrationComplete,
};
class CloudFormation extends CloudFormationClient {
}
client.createAggregatedClient(commands, CloudFormation, { paginators, waiters });

const AccountFilterType = {
    DIFFERENCE: "DIFFERENCE",
    INTERSECTION: "INTERSECTION",
    NONE: "NONE",
    UNION: "UNION",
};
const AccountGateStatus = {
    FAILED: "FAILED",
    SKIPPED: "SKIPPED",
    SUCCEEDED: "SUCCEEDED",
};
const ThirdPartyType = {
    HOOK: "HOOK",
    MODULE: "MODULE",
    RESOURCE: "RESOURCE",
};
const VersionBump = {
    MAJOR: "MAJOR",
    MINOR: "MINOR",
};
const AfterValueFrom = {
    TEMPLATE: "TEMPLATE",
};
const AnnotationSeverityLevel = {
    CRITICAL: "CRITICAL",
    HIGH: "HIGH",
    INFORMATIONAL: "INFORMATIONAL",
    LOW: "LOW",
    MEDIUM: "MEDIUM",
};
const AnnotationStatus = {
    FAILED: "FAILED",
    PASSED: "PASSED",
    SKIPPED: "SKIPPED",
};
const AttributeChangeType = {
    Add: "Add",
    Modify: "Modify",
    Remove: "Remove",
    SyncWithActual: "SyncWithActual",
};
const BeaconStackOperationStatus = {
    FAILED: "FAILED",
    IN_PROGRESS: "IN_PROGRESS",
    SUCCEEDED: "SUCCEEDED",
};
const BeforeValueFrom = {
    ACTUAL_STATE: "ACTUAL_STATE",
    PREVIOUS_DEPLOYMENT_STATE: "PREVIOUS_DEPLOYMENT_STATE",
};
const CallAs = {
    DELEGATED_ADMIN: "DELEGATED_ADMIN",
    SELF: "SELF",
};
const Capability = {
    CAPABILITY_AUTO_EXPAND: "CAPABILITY_AUTO_EXPAND",
    CAPABILITY_IAM: "CAPABILITY_IAM",
    CAPABILITY_NAMED_IAM: "CAPABILITY_NAMED_IAM",
};
const Category = {
    ACTIVATED: "ACTIVATED",
    AWS_TYPES: "AWS_TYPES",
    REGISTERED: "REGISTERED",
    THIRD_PARTY: "THIRD_PARTY",
};
const ChangeAction = {
    Add: "Add",
    Dynamic: "Dynamic",
    Import: "Import",
    Modify: "Modify",
    Remove: "Remove",
    SyncWithActual: "SyncWithActual",
};
const ChangeSource = {
    Automatic: "Automatic",
    DirectModification: "DirectModification",
    NoModification: "NoModification",
    ParameterReference: "ParameterReference",
    ResourceAttribute: "ResourceAttribute",
    ResourceReference: "ResourceReference",
};
const EvaluationType = {
    Dynamic: "Dynamic",
    Static: "Static",
};
const ResourceAttribute = {
    CreationPolicy: "CreationPolicy",
    DeletionPolicy: "DeletionPolicy",
    Metadata: "Metadata",
    Properties: "Properties",
    Tags: "Tags",
    UpdatePolicy: "UpdatePolicy",
    UpdateReplacePolicy: "UpdateReplacePolicy",
};
const RequiresRecreation = {
    Always: "Always",
    Conditionally: "Conditionally",
    Never: "Never",
};
const PolicyAction = {
    Delete: "Delete",
    ReplaceAndDelete: "ReplaceAndDelete",
    ReplaceAndRetain: "ReplaceAndRetain",
    ReplaceAndSnapshot: "ReplaceAndSnapshot",
    Retain: "Retain",
    Snapshot: "Snapshot",
};
const Replacement = {
    Conditional: "Conditional",
    False: "False",
    True: "True",
};
const DriftIgnoredReason = {
    MANAGED_BY_AWS: "MANAGED_BY_AWS",
    WRITE_ONLY_PROPERTY: "WRITE_ONLY_PROPERTY",
};
const StackResourceDriftStatus = {
    DELETED: "DELETED",
    IN_SYNC: "IN_SYNC",
    MODIFIED: "MODIFIED",
    NOT_CHECKED: "NOT_CHECKED",
    UNKNOWN: "UNKNOWN",
    UNSUPPORTED: "UNSUPPORTED",
};
const ChangeType = {
    Resource: "Resource",
};
const HookFailureMode = {
    FAIL: "FAIL",
    WARN: "WARN",
};
const HookInvocationPoint = {
    PRE_PROVISION: "PRE_PROVISION",
};
const HookTargetType = {
    RESOURCE: "RESOURCE",
};
const ChangeSetHooksStatus = {
    PLANNED: "PLANNED",
    PLANNING: "PLANNING",
    UNAVAILABLE: "UNAVAILABLE",
};
const ChangeSetStatus = {
    CREATE_COMPLETE: "CREATE_COMPLETE",
    CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
    CREATE_PENDING: "CREATE_PENDING",
    DELETE_COMPLETE: "DELETE_COMPLETE",
    DELETE_FAILED: "DELETE_FAILED",
    DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
    DELETE_PENDING: "DELETE_PENDING",
    FAILED: "FAILED",
};
const ExecutionStatus = {
    AVAILABLE: "AVAILABLE",
    EXECUTE_COMPLETE: "EXECUTE_COMPLETE",
    EXECUTE_FAILED: "EXECUTE_FAILED",
    EXECUTE_IN_PROGRESS: "EXECUTE_IN_PROGRESS",
    OBSOLETE: "OBSOLETE",
    UNAVAILABLE: "UNAVAILABLE",
};
const ChangeSetType = {
    CREATE: "CREATE",
    IMPORT: "IMPORT",
    UPDATE: "UPDATE",
};
const DeploymentMode = {
    REVERT_DRIFT: "REVERT_DRIFT",
};
const OnStackFailure = {
    DELETE: "DELETE",
    DO_NOTHING: "DO_NOTHING",
    ROLLBACK: "ROLLBACK",
};
const GeneratedTemplateDeletionPolicy = {
    DELETE: "DELETE",
    RETAIN: "RETAIN",
};
const GeneratedTemplateUpdateReplacePolicy = {
    DELETE: "DELETE",
    RETAIN: "RETAIN",
};
const OnFailure = {
    DELETE: "DELETE",
    DO_NOTHING: "DO_NOTHING",
    ROLLBACK: "ROLLBACK",
};
const ConcurrencyMode = {
    SOFT_FAILURE_TOLERANCE: "SOFT_FAILURE_TOLERANCE",
    STRICT_FAILURE_TOLERANCE: "STRICT_FAILURE_TOLERANCE",
};
const RegionConcurrencyType = {
    PARALLEL: "PARALLEL",
    SEQUENTIAL: "SEQUENTIAL",
};
const PermissionModels = {
    SELF_MANAGED: "SELF_MANAGED",
    SERVICE_MANAGED: "SERVICE_MANAGED",
};
const DeletionMode = {
    FORCE_DELETE_STACK: "FORCE_DELETE_STACK",
    STANDARD: "STANDARD",
};
const RegistryType = {
    HOOK: "HOOK",
    MODULE: "MODULE",
    RESOURCE: "RESOURCE",
};
const StackDriftStatus = {
    DRIFTED: "DRIFTED",
    IN_SYNC: "IN_SYNC",
    NOT_CHECKED: "NOT_CHECKED",
    UNKNOWN: "UNKNOWN",
};
const DetailedStatus = {
    CONFIGURATION_COMPLETE: "CONFIGURATION_COMPLETE",
    VALIDATION_FAILED: "VALIDATION_FAILED",
};
const EventType = {
    HOOK_INVOCATION_ERROR: "HOOK_INVOCATION_ERROR",
    PROGRESS_EVENT: "PROGRESS_EVENT",
    PROVISIONING_ERROR: "PROVISIONING_ERROR",
    STACK_EVENT: "STACK_EVENT",
    VALIDATION_ERROR: "VALIDATION_ERROR",
};
const HookStatus = {
    HOOK_COMPLETE_FAILED: "HOOK_COMPLETE_FAILED",
    HOOK_COMPLETE_SUCCEEDED: "HOOK_COMPLETE_SUCCEEDED",
    HOOK_FAILED: "HOOK_FAILED",
    HOOK_IN_PROGRESS: "HOOK_IN_PROGRESS",
};
const OperationType = {
    CONTINUE_ROLLBACK: "CONTINUE_ROLLBACK",
    CREATE_CHANGESET: "CREATE_CHANGESET",
    CREATE_STACK: "CREATE_STACK",
    DELETE_STACK: "DELETE_STACK",
    ROLLBACK: "ROLLBACK",
    UPDATE_STACK: "UPDATE_STACK",
};
const ResourceStatus = {
    CREATE_COMPLETE: "CREATE_COMPLETE",
    CREATE_FAILED: "CREATE_FAILED",
    CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
    DELETE_COMPLETE: "DELETE_COMPLETE",
    DELETE_FAILED: "DELETE_FAILED",
    DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
    DELETE_SKIPPED: "DELETE_SKIPPED",
    EXPORT_COMPLETE: "EXPORT_COMPLETE",
    EXPORT_FAILED: "EXPORT_FAILED",
    EXPORT_IN_PROGRESS: "EXPORT_IN_PROGRESS",
    EXPORT_ROLLBACK_COMPLETE: "EXPORT_ROLLBACK_COMPLETE",
    EXPORT_ROLLBACK_FAILED: "EXPORT_ROLLBACK_FAILED",
    EXPORT_ROLLBACK_IN_PROGRESS: "EXPORT_ROLLBACK_IN_PROGRESS",
    IMPORT_COMPLETE: "IMPORT_COMPLETE",
    IMPORT_FAILED: "IMPORT_FAILED",
    IMPORT_IN_PROGRESS: "IMPORT_IN_PROGRESS",
    IMPORT_ROLLBACK_COMPLETE: "IMPORT_ROLLBACK_COMPLETE",
    IMPORT_ROLLBACK_FAILED: "IMPORT_ROLLBACK_FAILED",
    IMPORT_ROLLBACK_IN_PROGRESS: "IMPORT_ROLLBACK_IN_PROGRESS",
    ROLLBACK_COMPLETE: "ROLLBACK_COMPLETE",
    ROLLBACK_FAILED: "ROLLBACK_FAILED",
    ROLLBACK_IN_PROGRESS: "ROLLBACK_IN_PROGRESS",
    UPDATE_COMPLETE: "UPDATE_COMPLETE",
    UPDATE_FAILED: "UPDATE_FAILED",
    UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS",
    UPDATE_ROLLBACK_COMPLETE: "UPDATE_ROLLBACK_COMPLETE",
    UPDATE_ROLLBACK_FAILED: "UPDATE_ROLLBACK_FAILED",
    UPDATE_ROLLBACK_IN_PROGRESS: "UPDATE_ROLLBACK_IN_PROGRESS",
};
const ValidationStatus = {
    FAILED: "FAILED",
    SKIPPED: "SKIPPED",
};
const GeneratedTemplateResourceStatus = {
    COMPLETE: "COMPLETE",
    FAILED: "FAILED",
    IN_PROGRESS: "IN_PROGRESS",
    PENDING: "PENDING",
};
const WarningType = {
    EXCLUDED_PROPERTIES: "EXCLUDED_PROPERTIES",
    EXCLUDED_RESOURCES: "EXCLUDED_RESOURCES",
    MUTUALLY_EXCLUSIVE_PROPERTIES: "MUTUALLY_EXCLUSIVE_PROPERTIES",
    MUTUALLY_EXCLUSIVE_TYPES: "MUTUALLY_EXCLUSIVE_TYPES",
    UNSUPPORTED_PROPERTIES: "UNSUPPORTED_PROPERTIES",
};
const GeneratedTemplateStatus = {
    COMPLETE: "COMPLETE",
    CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
    CREATE_PENDING: "CREATE_PENDING",
    DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
    DELETE_PENDING: "DELETE_PENDING",
    FAILED: "FAILED",
    UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS",
    UPDATE_PENDING: "UPDATE_PENDING",
};
const OrganizationStatus = {
    DISABLED: "DISABLED",
    DISABLED_PERMANENTLY: "DISABLED_PERMANENTLY",
    ENABLED: "ENABLED",
};
const IdentityProvider = {
    AWS_Marketplace: "AWS_Marketplace",
    Bitbucket: "Bitbucket",
    GitHub: "GitHub",
};
const PublisherStatus = {
    UNVERIFIED: "UNVERIFIED",
    VERIFIED: "VERIFIED",
};
const ResourceScanStatus = {
    COMPLETE: "COMPLETE",
    EXPIRED: "EXPIRED",
    FAILED: "FAILED",
    IN_PROGRESS: "IN_PROGRESS",
};
const StackDriftDetectionStatus = {
    DETECTION_COMPLETE: "DETECTION_COMPLETE",
    DETECTION_FAILED: "DETECTION_FAILED",
    DETECTION_IN_PROGRESS: "DETECTION_IN_PROGRESS",
};
const StackInstanceDetailedStatus = {
    CANCELLED: "CANCELLED",
    FAILED: "FAILED",
    FAILED_IMPORT: "FAILED_IMPORT",
    INOPERABLE: "INOPERABLE",
    PENDING: "PENDING",
    RUNNING: "RUNNING",
    SKIPPED_SUSPENDED_ACCOUNT: "SKIPPED_SUSPENDED_ACCOUNT",
    SUCCEEDED: "SUCCEEDED",
};
const StackInstanceStatus = {
    CURRENT: "CURRENT",
    INOPERABLE: "INOPERABLE",
    OUTDATED: "OUTDATED",
};
const StackRefactorExecutionStatus = {
    AVAILABLE: "AVAILABLE",
    EXECUTE_COMPLETE: "EXECUTE_COMPLETE",
    EXECUTE_FAILED: "EXECUTE_FAILED",
    EXECUTE_IN_PROGRESS: "EXECUTE_IN_PROGRESS",
    OBSOLETE: "OBSOLETE",
    ROLLBACK_COMPLETE: "ROLLBACK_COMPLETE",
    ROLLBACK_FAILED: "ROLLBACK_FAILED",
    ROLLBACK_IN_PROGRESS: "ROLLBACK_IN_PROGRESS",
    UNAVAILABLE: "UNAVAILABLE",
};
const StackRefactorStatus = {
    CREATE_COMPLETE: "CREATE_COMPLETE",
    CREATE_FAILED: "CREATE_FAILED",
    CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
    DELETE_COMPLETE: "DELETE_COMPLETE",
    DELETE_FAILED: "DELETE_FAILED",
    DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
};
const DifferenceType = {
    ADD: "ADD",
    NOT_EQUAL: "NOT_EQUAL",
    REMOVE: "REMOVE",
};
const StackStatus = {
    CREATE_COMPLETE: "CREATE_COMPLETE",
    CREATE_FAILED: "CREATE_FAILED",
    CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
    DELETE_COMPLETE: "DELETE_COMPLETE",
    DELETE_FAILED: "DELETE_FAILED",
    DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
    IMPORT_COMPLETE: "IMPORT_COMPLETE",
    IMPORT_IN_PROGRESS: "IMPORT_IN_PROGRESS",
    IMPORT_ROLLBACK_COMPLETE: "IMPORT_ROLLBACK_COMPLETE",
    IMPORT_ROLLBACK_FAILED: "IMPORT_ROLLBACK_FAILED",
    IMPORT_ROLLBACK_IN_PROGRESS: "IMPORT_ROLLBACK_IN_PROGRESS",
    REVIEW_IN_PROGRESS: "REVIEW_IN_PROGRESS",
    ROLLBACK_COMPLETE: "ROLLBACK_COMPLETE",
    ROLLBACK_FAILED: "ROLLBACK_FAILED",
    ROLLBACK_IN_PROGRESS: "ROLLBACK_IN_PROGRESS",
    UPDATE_COMPLETE: "UPDATE_COMPLETE",
    UPDATE_COMPLETE_CLEANUP_IN_PROGRESS: "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS",
    UPDATE_FAILED: "UPDATE_FAILED",
    UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS",
    UPDATE_ROLLBACK_COMPLETE: "UPDATE_ROLLBACK_COMPLETE",
    UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS: "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS",
    UPDATE_ROLLBACK_FAILED: "UPDATE_ROLLBACK_FAILED",
    UPDATE_ROLLBACK_IN_PROGRESS: "UPDATE_ROLLBACK_IN_PROGRESS",
};
const StackSetDriftDetectionStatus = {
    COMPLETED: "COMPLETED",
    FAILED: "FAILED",
    IN_PROGRESS: "IN_PROGRESS",
    PARTIAL_SUCCESS: "PARTIAL_SUCCESS",
    STOPPED: "STOPPED",
};
const StackSetDriftStatus = {
    DRIFTED: "DRIFTED",
    IN_SYNC: "IN_SYNC",
    NOT_CHECKED: "NOT_CHECKED",
};
const StackSetStatus = {
    ACTIVE: "ACTIVE",
    DELETED: "DELETED",
};
const StackSetOperationAction = {
    CREATE: "CREATE",
    DELETE: "DELETE",
    DETECT_DRIFT: "DETECT_DRIFT",
    UPDATE: "UPDATE",
};
const StackSetOperationStatus = {
    FAILED: "FAILED",
    QUEUED: "QUEUED",
    RUNNING: "RUNNING",
    STOPPED: "STOPPED",
    STOPPING: "STOPPING",
    SUCCEEDED: "SUCCEEDED",
};
const DeprecatedStatus = {
    DEPRECATED: "DEPRECATED",
    LIVE: "LIVE",
};
const ProvisioningType = {
    FULLY_MUTABLE: "FULLY_MUTABLE",
    IMMUTABLE: "IMMUTABLE",
    NON_PROVISIONABLE: "NON_PROVISIONABLE",
};
const TypeTestsStatus = {
    FAILED: "FAILED",
    IN_PROGRESS: "IN_PROGRESS",
    NOT_TESTED: "NOT_TESTED",
    PASSED: "PASSED",
};
const Visibility = {
    PRIVATE: "PRIVATE",
    PUBLIC: "PUBLIC",
};
const RegistrationStatus = {
    COMPLETE: "COMPLETE",
    FAILED: "FAILED",
    IN_PROGRESS: "IN_PROGRESS",
};
const TemplateFormat = {
    JSON: "JSON",
    YAML: "YAML",
};
const HookTargetAction = {
    CREATE: "CREATE",
    DELETE: "DELETE",
    IMPORT: "IMPORT",
    UPDATE: "UPDATE",
};
const TemplateStage = {
    Original: "Original",
    Processed: "Processed",
};
const ListHookResultsTargetType = {
    CHANGE_SET: "CHANGE_SET",
    CLOUD_CONTROL: "CLOUD_CONTROL",
    RESOURCE: "RESOURCE",
    STACK: "STACK",
};
const ScanType = {
    FULL: "FULL",
    PARTIAL: "PARTIAL",
};
const StackInstanceFilterName = {
    DETAILED_STATUS: "DETAILED_STATUS",
    DRIFT_STATUS: "DRIFT_STATUS",
    LAST_OPERATION_ID: "LAST_OPERATION_ID",
};
const StackRefactorActionType = {
    CREATE: "CREATE",
    MOVE: "MOVE",
};
const StackRefactorDetection = {
    AUTO: "AUTO",
    MANUAL: "MANUAL",
};
const StackRefactorActionEntity = {
    RESOURCE: "RESOURCE",
    STACK: "STACK",
};
const OperationResultFilterName = {
    OPERATION_RESULT_STATUS: "OPERATION_RESULT_STATUS",
};
const StackSetOperationResultStatus = {
    CANCELLED: "CANCELLED",
    FAILED: "FAILED",
    PENDING: "PENDING",
    RUNNING: "RUNNING",
    SUCCEEDED: "SUCCEEDED",
};
const OperationStatus = {
    FAILED: "FAILED",
    IN_PROGRESS: "IN_PROGRESS",
    PENDING: "PENDING",
    SUCCESS: "SUCCESS",
};
const HandlerErrorCode = {
    AccessDenied: "AccessDenied",
    AlreadyExists: "AlreadyExists",
    GeneralServiceException: "GeneralServiceException",
    HandlerInternalFailure: "HandlerInternalFailure",
    InternalFailure: "InternalFailure",
    InvalidCredentials: "InvalidCredentials",
    InvalidRequest: "InvalidRequest",
    InvalidTypeConfiguration: "InvalidTypeConfiguration",
    NetworkFailure: "NetworkFailure",
    NonCompliant: "NonCompliant",
    NotFound: "NotFound",
    NotUpdatable: "NotUpdatable",
    ResourceConflict: "ResourceConflict",
    ServiceInternalError: "ServiceInternalError",
    ServiceLimitExceeded: "ServiceLimitExceeded",
    ServiceTimeout: "NotStabilized",
    Throttling: "Throttling",
    Unknown: "Unknown",
    UnsupportedTarget: "UnsupportedTarget",
};
const ResourceSignalStatus = {
    FAILURE: "FAILURE",
    SUCCESS: "SUCCESS",
};

exports.$Command = client.Command;
exports.__Client = client.Client;
exports.CloudFormationServiceException = CloudFormationServiceException.CloudFormationServiceException;
exports.AccountFilterType = AccountFilterType;
exports.AccountGateStatus = AccountGateStatus;
exports.ActivateOrganizationsAccessCommand = ActivateOrganizationsAccessCommand;
exports.ActivateTypeCommand = ActivateTypeCommand;
exports.AfterValueFrom = AfterValueFrom;
exports.AnnotationSeverityLevel = AnnotationSeverityLevel;
exports.AnnotationStatus = AnnotationStatus;
exports.AttributeChangeType = AttributeChangeType;
exports.BatchDescribeTypeConfigurationsCommand = BatchDescribeTypeConfigurationsCommand;
exports.BeaconStackOperationStatus = BeaconStackOperationStatus;
exports.BeforeValueFrom = BeforeValueFrom;
exports.CallAs = CallAs;
exports.CancelUpdateStackCommand = CancelUpdateStackCommand;
exports.Capability = Capability;
exports.Category = Category;
exports.ChangeAction = ChangeAction;
exports.ChangeSetHooksStatus = ChangeSetHooksStatus;
exports.ChangeSetStatus = ChangeSetStatus;
exports.ChangeSetType = ChangeSetType;
exports.ChangeSource = ChangeSource;
exports.ChangeType = ChangeType;
exports.CloudFormation = CloudFormation;
exports.CloudFormationClient = CloudFormationClient;
exports.ConcurrencyMode = ConcurrencyMode;
exports.ContinueUpdateRollbackCommand = ContinueUpdateRollbackCommand;
exports.CreateChangeSetCommand = CreateChangeSetCommand;
exports.CreateGeneratedTemplateCommand = CreateGeneratedTemplateCommand;
exports.CreateStackCommand = CreateStackCommand;
exports.CreateStackInstancesCommand = CreateStackInstancesCommand;
exports.CreateStackRefactorCommand = CreateStackRefactorCommand;
exports.CreateStackSetCommand = CreateStackSetCommand;
exports.DeactivateOrganizationsAccessCommand = DeactivateOrganizationsAccessCommand;
exports.DeactivateTypeCommand = DeactivateTypeCommand;
exports.DeleteChangeSetCommand = DeleteChangeSetCommand;
exports.DeleteGeneratedTemplateCommand = DeleteGeneratedTemplateCommand;
exports.DeleteStackCommand = DeleteStackCommand;
exports.DeleteStackInstancesCommand = DeleteStackInstancesCommand;
exports.DeleteStackSetCommand = DeleteStackSetCommand;
exports.DeletionMode = DeletionMode;
exports.DeploymentMode = DeploymentMode;
exports.DeprecatedStatus = DeprecatedStatus;
exports.DeregisterTypeCommand = DeregisterTypeCommand;
exports.DescribeAccountLimitsCommand = DescribeAccountLimitsCommand;
exports.DescribeChangeSetCommand = DescribeChangeSetCommand;
exports.DescribeChangeSetHooksCommand = DescribeChangeSetHooksCommand;
exports.DescribeEventsCommand = DescribeEventsCommand;
exports.DescribeGeneratedTemplateCommand = DescribeGeneratedTemplateCommand;
exports.DescribeOrganizationsAccessCommand = DescribeOrganizationsAccessCommand;
exports.DescribePublisherCommand = DescribePublisherCommand;
exports.DescribeResourceScanCommand = DescribeResourceScanCommand;
exports.DescribeStackDriftDetectionStatusCommand = DescribeStackDriftDetectionStatusCommand;
exports.DescribeStackEventsCommand = DescribeStackEventsCommand;
exports.DescribeStackInstanceCommand = DescribeStackInstanceCommand;
exports.DescribeStackRefactorCommand = DescribeStackRefactorCommand;
exports.DescribeStackResourceCommand = DescribeStackResourceCommand;
exports.DescribeStackResourceDriftsCommand = DescribeStackResourceDriftsCommand;
exports.DescribeStackResourcesCommand = DescribeStackResourcesCommand;
exports.DescribeStackSetCommand = DescribeStackSetCommand;
exports.DescribeStackSetOperationCommand = DescribeStackSetOperationCommand;
exports.DescribeStacksCommand = DescribeStacksCommand;
exports.DescribeTypeCommand = DescribeTypeCommand;
exports.DescribeTypeRegistrationCommand = DescribeTypeRegistrationCommand;
exports.DetailedStatus = DetailedStatus;
exports.DetectStackDriftCommand = DetectStackDriftCommand;
exports.DetectStackResourceDriftCommand = DetectStackResourceDriftCommand;
exports.DetectStackSetDriftCommand = DetectStackSetDriftCommand;
exports.DifferenceType = DifferenceType;
exports.DriftIgnoredReason = DriftIgnoredReason;
exports.EstimateTemplateCostCommand = EstimateTemplateCostCommand;
exports.EvaluationType = EvaluationType;
exports.EventType = EventType;
exports.ExecuteChangeSetCommand = ExecuteChangeSetCommand;
exports.ExecuteStackRefactorCommand = ExecuteStackRefactorCommand;
exports.ExecutionStatus = ExecutionStatus;
exports.GeneratedTemplateDeletionPolicy = GeneratedTemplateDeletionPolicy;
exports.GeneratedTemplateResourceStatus = GeneratedTemplateResourceStatus;
exports.GeneratedTemplateStatus = GeneratedTemplateStatus;
exports.GeneratedTemplateUpdateReplacePolicy = GeneratedTemplateUpdateReplacePolicy;
exports.GetGeneratedTemplateCommand = GetGeneratedTemplateCommand;
exports.GetHookResultCommand = GetHookResultCommand;
exports.GetStackPolicyCommand = GetStackPolicyCommand;
exports.GetTemplateCommand = GetTemplateCommand;
exports.GetTemplateSummaryCommand = GetTemplateSummaryCommand;
exports.HandlerErrorCode = HandlerErrorCode;
exports.HookFailureMode = HookFailureMode;
exports.HookInvocationPoint = HookInvocationPoint;
exports.HookStatus = HookStatus;
exports.HookTargetAction = HookTargetAction;
exports.HookTargetType = HookTargetType;
exports.IdentityProvider = IdentityProvider;
exports.ImportStacksToStackSetCommand = ImportStacksToStackSetCommand;
exports.ListChangeSetsCommand = ListChangeSetsCommand;
exports.ListExportsCommand = ListExportsCommand;
exports.ListGeneratedTemplatesCommand = ListGeneratedTemplatesCommand;
exports.ListHookResultsCommand = ListHookResultsCommand;
exports.ListHookResultsTargetType = ListHookResultsTargetType;
exports.ListImportsCommand = ListImportsCommand;
exports.ListResourceScanRelatedResourcesCommand = ListResourceScanRelatedResourcesCommand;
exports.ListResourceScanResourcesCommand = ListResourceScanResourcesCommand;
exports.ListResourceScansCommand = ListResourceScansCommand;
exports.ListStackInstanceResourceDriftsCommand = ListStackInstanceResourceDriftsCommand;
exports.ListStackInstancesCommand = ListStackInstancesCommand;
exports.ListStackRefactorActionsCommand = ListStackRefactorActionsCommand;
exports.ListStackRefactorsCommand = ListStackRefactorsCommand;
exports.ListStackResourcesCommand = ListStackResourcesCommand;
exports.ListStackSetAutoDeploymentTargetsCommand = ListStackSetAutoDeploymentTargetsCommand;
exports.ListStackSetOperationResultsCommand = ListStackSetOperationResultsCommand;
exports.ListStackSetOperationsCommand = ListStackSetOperationsCommand;
exports.ListStackSetsCommand = ListStackSetsCommand;
exports.ListStacksCommand = ListStacksCommand;
exports.ListTypeRegistrationsCommand = ListTypeRegistrationsCommand;
exports.ListTypeVersionsCommand = ListTypeVersionsCommand;
exports.ListTypesCommand = ListTypesCommand;
exports.OnFailure = OnFailure;
exports.OnStackFailure = OnStackFailure;
exports.OperationResultFilterName = OperationResultFilterName;
exports.OperationStatus = OperationStatus;
exports.OperationType = OperationType;
exports.OrganizationStatus = OrganizationStatus;
exports.PermissionModels = PermissionModels;
exports.PolicyAction = PolicyAction;
exports.ProvisioningType = ProvisioningType;
exports.PublishTypeCommand = PublishTypeCommand;
exports.PublisherStatus = PublisherStatus;
exports.RecordHandlerProgressCommand = RecordHandlerProgressCommand;
exports.RegionConcurrencyType = RegionConcurrencyType;
exports.RegisterPublisherCommand = RegisterPublisherCommand;
exports.RegisterTypeCommand = RegisterTypeCommand;
exports.RegistrationStatus = RegistrationStatus;
exports.RegistryType = RegistryType;
exports.Replacement = Replacement;
exports.RequiresRecreation = RequiresRecreation;
exports.ResourceAttribute = ResourceAttribute;
exports.ResourceScanStatus = ResourceScanStatus;
exports.ResourceSignalStatus = ResourceSignalStatus;
exports.ResourceStatus = ResourceStatus;
exports.RollbackStackCommand = RollbackStackCommand;
exports.ScanType = ScanType;
exports.SetStackPolicyCommand = SetStackPolicyCommand;
exports.SetTypeConfigurationCommand = SetTypeConfigurationCommand;
exports.SetTypeDefaultVersionCommand = SetTypeDefaultVersionCommand;
exports.SignalResourceCommand = SignalResourceCommand;
exports.StackDriftDetectionStatus = StackDriftDetectionStatus;
exports.StackDriftStatus = StackDriftStatus;
exports.StackInstanceDetailedStatus = StackInstanceDetailedStatus;
exports.StackInstanceFilterName = StackInstanceFilterName;
exports.StackInstanceStatus = StackInstanceStatus;
exports.StackRefactorActionEntity = StackRefactorActionEntity;
exports.StackRefactorActionType = StackRefactorActionType;
exports.StackRefactorDetection = StackRefactorDetection;
exports.StackRefactorExecutionStatus = StackRefactorExecutionStatus;
exports.StackRefactorStatus = StackRefactorStatus;
exports.StackResourceDriftStatus = StackResourceDriftStatus;
exports.StackSetDriftDetectionStatus = StackSetDriftDetectionStatus;
exports.StackSetDriftStatus = StackSetDriftStatus;
exports.StackSetOperationAction = StackSetOperationAction;
exports.StackSetOperationResultStatus = StackSetOperationResultStatus;
exports.StackSetOperationStatus = StackSetOperationStatus;
exports.StackSetStatus = StackSetStatus;
exports.StackStatus = StackStatus;
exports.StartResourceScanCommand = StartResourceScanCommand;
exports.StopStackSetOperationCommand = StopStackSetOperationCommand;
exports.TemplateFormat = TemplateFormat;
exports.TemplateStage = TemplateStage;
exports.TestTypeCommand = TestTypeCommand;
exports.ThirdPartyType = ThirdPartyType;
exports.TypeTestsStatus = TypeTestsStatus;
exports.UpdateGeneratedTemplateCommand = UpdateGeneratedTemplateCommand;
exports.UpdateStackCommand = UpdateStackCommand;
exports.UpdateStackInstancesCommand = UpdateStackInstancesCommand;
exports.UpdateStackSetCommand = UpdateStackSetCommand;
exports.UpdateTerminationProtectionCommand = UpdateTerminationProtectionCommand;
exports.ValidateTemplateCommand = ValidateTemplateCommand;
exports.ValidationStatus = ValidationStatus;
exports.VersionBump = VersionBump;
exports.Visibility = Visibility;
exports.WarningType = WarningType;
exports.paginateDescribeAccountLimits = paginateDescribeAccountLimits;
exports.paginateDescribeChangeSet = paginateDescribeChangeSet;
exports.paginateDescribeEvents = paginateDescribeEvents;
exports.paginateDescribeStackEvents = paginateDescribeStackEvents;
exports.paginateDescribeStackResourceDrifts = paginateDescribeStackResourceDrifts;
exports.paginateDescribeStacks = paginateDescribeStacks;
exports.paginateListChangeSets = paginateListChangeSets;
exports.paginateListExports = paginateListExports;
exports.paginateListGeneratedTemplates = paginateListGeneratedTemplates;
exports.paginateListImports = paginateListImports;
exports.paginateListResourceScanRelatedResources = paginateListResourceScanRelatedResources;
exports.paginateListResourceScanResources = paginateListResourceScanResources;
exports.paginateListResourceScans = paginateListResourceScans;
exports.paginateListStackInstances = paginateListStackInstances;
exports.paginateListStackRefactorActions = paginateListStackRefactorActions;
exports.paginateListStackRefactors = paginateListStackRefactors;
exports.paginateListStackResources = paginateListStackResources;
exports.paginateListStackSetOperationResults = paginateListStackSetOperationResults;
exports.paginateListStackSetOperations = paginateListStackSetOperations;
exports.paginateListStackSets = paginateListStackSets;
exports.paginateListStacks = paginateListStacks;
exports.paginateListTypeRegistrations = paginateListTypeRegistrations;
exports.paginateListTypeVersions = paginateListTypeVersions;
exports.paginateListTypes = paginateListTypes;
exports.waitForChangeSetCreateComplete = waitForChangeSetCreateComplete;
exports.waitForStackCreateComplete = waitForStackCreateComplete;
exports.waitForStackDeleteComplete = waitForStackDeleteComplete;
exports.waitForStackExists = waitForStackExists;
exports.waitForStackImportComplete = waitForStackImportComplete;
exports.waitForStackRefactorCreateComplete = waitForStackRefactorCreateComplete;
exports.waitForStackRefactorExecuteComplete = waitForStackRefactorExecuteComplete;
exports.waitForStackRollbackComplete = waitForStackRollbackComplete;
exports.waitForStackUpdateComplete = waitForStackUpdateComplete;
exports.waitForTypeRegistrationComplete = waitForTypeRegistrationComplete;
exports.waitUntilChangeSetCreateComplete = waitUntilChangeSetCreateComplete;
exports.waitUntilStackCreateComplete = waitUntilStackCreateComplete;
exports.waitUntilStackDeleteComplete = waitUntilStackDeleteComplete;
exports.waitUntilStackExists = waitUntilStackExists;
exports.waitUntilStackImportComplete = waitUntilStackImportComplete;
exports.waitUntilStackRefactorCreateComplete = waitUntilStackRefactorCreateComplete;
exports.waitUntilStackRefactorExecuteComplete = waitUntilStackRefactorExecuteComplete;
exports.waitUntilStackRollbackComplete = waitUntilStackRollbackComplete;
exports.waitUntilStackUpdateComplete = waitUntilStackUpdateComplete;
exports.waitUntilTypeRegistrationComplete = waitUntilTypeRegistrationComplete;
Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&
    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
    Object.defineProperty(exports, '__proto__', {
        enumerable: true,
        value: schemas_0['__proto__']
    });

Object.keys(schemas_0).forEach(function (k) {
    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];
});
Object.prototype.hasOwnProperty.call(errors, '__proto__') &&
    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
    Object.defineProperty(exports, '__proto__', {
        enumerable: true,
        value: errors['__proto__']
    });

Object.keys(errors).forEach(function (k) {
    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];
});