lambda-live-debugger/node_modules/@aws-sdk/client-cloudformation/dist-cjs/index.js

Debug Lambda functions locally like it is running in the cloud

'use strict';

var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
var middlewareLogger = require('@aws-sdk/middleware-logger');
var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
var configResolver = require('@smithy/config-resolver');
var core = require('@smithy/core');
var schema = require('@smithy/core/schema');
var middlewareContentLength = require('@smithy/middleware-content-length');
var middlewareEndpoint = require('@smithy/middleware-endpoint');
var middlewareRetry = require('@smithy/middleware-retry');
var smithyClient = require('@smithy/smithy-client');
var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
var runtimeConfig = require('./runtimeConfig');
var regionConfigResolver = require('@aws-sdk/region-config-resolver');
var protocolHttp = require('@smithy/protocol-http');
var schemas_0 = require('./schemas/schemas_0');
var utilWaiter = require('@smithy/util-waiter');
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(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
    extensions.forEach((extension) => extension.configure(extensionConfiguration));
    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
};

class CloudFormationClient extends smithyClient.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 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
        const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
        const _config_4 = configResolver.resolveRegionConfig(_config_3);
        const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
        const _config_6 = middlewareEndpoint.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(middlewareUserAgent.getUserAgentPlugin(this.config));
        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
        this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
        this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
        this.middlewareStack.use(middlewareRecursionDetection.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 smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("CloudFormation", "ActivateOrganizationsAccess", {})
    .n("CloudFormationClient", "ActivateOrganizationsAccessCommand")
    .sc(schemas_0.ActivateOrganizationsAccess$)
    .build() {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class ValidateTemplateCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.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, input) => {
    let reason;
    try {
        let result = await client.send(new DescribeChangeSetCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.Status;
            };
            if (returnComparator() === "CREATE_COMPLETE") {
                return { state: utilWaiter.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.Status;
            };
            if (returnComparator() === "FAILED") {
                return { state: utilWaiter.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
        if (exception.name && exception.name == "ValidationError") {
            return { state: utilWaiter.WaiterState.FAILURE, reason };
        }
    }
    return { state: utilWaiter.WaiterState.RETRY, reason };
};
const waitForChangeSetCreateComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
};
const waitUntilChangeSetCreateComplete = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
    return utilWaiter.checkExceptions(result);
};

const checkState$8 = async (client, input) => {
    let reason;
    try {
        let result = await client.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: utilWaiter.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                let flat_1 = [].concat(...result.Stacks);
                let projection_3 = flat_1.map((element_2) => {
                    retur