@rio-cloud/cdk-v2-constructs 8.1.0 → 8.2.0-alpha.0

package/node_modules/@aws-sdk/client-cloudformation/dist-cjs/index.js

@@ -1,22 +1,21 @@
-'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 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 regionConfigResolver = require('@aws-sdk/region-config-resolver');
-var schemas_0 = require('./schemas/schemas_0');
-var errors = require('./models/errors');
-var CloudFormationServiceException = require('./models/CloudFormationServiceException');
+var __exportStar = (m, e) => { Object.assign(e, m); };
+const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
+const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createWaiter, checkExceptions, WaiterState, createAggregatedClient } = require("@smithy/core/client");
+exports.$Command = Command;
+exports.__Client = Client;
+const { resolveRegionConfig } = require("@smithy/core/config");
+const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveHttpAuthSchemeConfig, defaultCloudFormationHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { ActivateOrganizationsAccess$, ActivateType$, BatchDescribeTypeConfigurations$, CancelUpdateStack$, ContinueUpdateRollback$, CreateChangeSet$, CreateGeneratedTemplate$, CreateStack$, CreateStackInstances$, CreateStackRefactor$, CreateStackSet$, DeactivateOrganizationsAccess$, DeactivateType$, DeleteChangeSet$, DeleteGeneratedTemplate$, DeleteStack$, DeleteStackInstances$, DeleteStackSet$, DeregisterType$, DescribeAccountLimits$, DescribeChangeSet$, DescribeChangeSetHooks$, DescribeEvents$, DescribeGeneratedTemplate$, DescribeOrganizationsAccess$, DescribePublisher$, DescribeResourceScan$, DescribeStackDriftDetectionStatus$, DescribeStackEvents$, DescribeStackInstance$, DescribeStackRefactor$, DescribeStackResource$, DescribeStackResourceDrifts$, DescribeStackResources$, DescribeStacks$, DescribeStackSet$, DescribeStackSetOperation$, DescribeType$, DescribeTypeRegistration$, DetectStackDrift$, DetectStackResourceDrift$, DetectStackSetDrift$, EstimateTemplateCost$, ExecuteChangeSet$, ExecuteStackRefactor$, GetGeneratedTemplate$, GetHookResult$, GetStackPolicy$, GetTemplate$, GetTemplateSummary$, ImportStacksToStackSet$, ListChangeSets$, ListExports$, ListGeneratedTemplates$, ListHookResults$, ListImports$, ListResourceScanRelatedResources$, ListResourceScanResources$, ListResourceScans$, ListStackInstanceResourceDrifts$, ListStackInstances$, ListStackRefactorActions$, ListStackRefactors$, ListStackResources$, ListStacks$, ListStackSetAutoDeploymentTargets$, ListStackSetOperationResults$, ListStackSetOperations$, ListStackSets$, ListTypeRegistrations$, ListTypes$, ListTypeVersions$, PublishType$, RecordHandlerProgress$, RegisterPublisher$, RegisterType$, RollbackStack$, SetStackPolicy$, SetTypeConfiguration$, SetTypeDefaultVersion$, SignalResource$, StartResourceScan$, StopStackSetOperation$, TestType$, UpdateGeneratedTemplate$, UpdateStack$, UpdateStackInstances$, UpdateStackSet$, UpdateTerminationProtection$, ValidateTemplate$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+__exportStar(require("./models/errors"), exports);
+const { CloudFormationServiceException } = require("./models/CloudFormationServiceException");
+exports.CloudFormationServiceException = CloudFormationServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -72,1185 +71,1185 @@ const resolveHttpAuthRuntimeConfig = (config) => {
 };
 
 const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
     extensions.forEach((extension) => extension.configure(extensionConfiguration));
-    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+    return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
 };
 
-class CloudFormationClient extends client.Client {
+class CloudFormationClient extends Client {
     config;
     constructor(...[configuration]) {
-        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        const _config_0 = 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 = retry.resolveRetryConfig(_config_2);
-        const _config_4 = config.resolveRegionConfig(_config_3);
-        const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
-        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
-        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_2 = resolveUserAgentConfig(_config_1);
+        const _config_3 = resolveRetryConfig(_config_2);
+        const _config_4 = resolveRegionConfig(_config_3);
+        const _config_5 = resolveHostHeaderConfig(_config_4);
+        const _config_6 = resolveEndpointConfig(_config_5);
+        const _config_7 = 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(retry.getRetryPlugin(this.config));
-        this.middlewareStack.use(protocols.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({
+        this.middlewareStack.use(getSchemaSerdePlugin(this.config));
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
+        this.middlewareStack.use(getRetryPlugin(this.config));
+        this.middlewareStack.use(getContentLengthPlugin(this.config));
+        this.middlewareStack.use(getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(getLoggerPlugin(this.config));
+        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: defaultCloudFormationHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
                 "aws.auth#sigv4": config.credentials,
             }),
         }));
-        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+        this.middlewareStack.use(getHttpSigningPlugin(this.config));
     }
     destroy() {
         super.destroy();
     }
 }
 
-class ActivateOrganizationsAccessCommand extends client.Command
+class ActivateOrganizationsAccessCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ActivateOrganizationsAccess", {})
     .n("CloudFormationClient", "ActivateOrganizationsAccessCommand")
-    .sc(schemas_0.ActivateOrganizationsAccess$)
+    .sc(ActivateOrganizationsAccess$)
     .build() {
 }
 
-class ActivateTypeCommand extends client.Command
+class ActivateTypeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ActivateType", {})
     .n("CloudFormationClient", "ActivateTypeCommand")
-    .sc(schemas_0.ActivateType$)
+    .sc(ActivateType$)
     .build() {
 }
 
-class BatchDescribeTypeConfigurationsCommand extends client.Command
+class BatchDescribeTypeConfigurationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "BatchDescribeTypeConfigurations", {})
     .n("CloudFormationClient", "BatchDescribeTypeConfigurationsCommand")
-    .sc(schemas_0.BatchDescribeTypeConfigurations$)
+    .sc(BatchDescribeTypeConfigurations$)
     .build() {
 }
 
-class CancelUpdateStackCommand extends client.Command
+class CancelUpdateStackCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "CancelUpdateStack", {})
     .n("CloudFormationClient", "CancelUpdateStackCommand")
-    .sc(schemas_0.CancelUpdateStack$)
+    .sc(CancelUpdateStack$)
     .build() {
 }
 
-class ContinueUpdateRollbackCommand extends client.Command
+class ContinueUpdateRollbackCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ContinueUpdateRollback", {})
     .n("CloudFormationClient", "ContinueUpdateRollbackCommand")
-    .sc(schemas_0.ContinueUpdateRollback$)
+    .sc(ContinueUpdateRollback$)
     .build() {
 }
 
-class CreateChangeSetCommand extends client.Command
+class CreateChangeSetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "CreateChangeSet", {})
     .n("CloudFormationClient", "CreateChangeSetCommand")
-    .sc(schemas_0.CreateChangeSet$)
+    .sc(CreateChangeSet$)
     .build() {
 }
 
-class CreateGeneratedTemplateCommand extends client.Command
+class CreateGeneratedTemplateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "CreateGeneratedTemplate", {})
     .n("CloudFormationClient", "CreateGeneratedTemplateCommand")
-    .sc(schemas_0.CreateGeneratedTemplate$)
+    .sc(CreateGeneratedTemplate$)
     .build() {
 }
 
-class CreateStackCommand extends client.Command
+class CreateStackCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "CreateStack", {})
     .n("CloudFormationClient", "CreateStackCommand")
-    .sc(schemas_0.CreateStack$)
+    .sc(CreateStack$)
     .build() {
 }
 
-class CreateStackInstancesCommand extends client.Command
+class CreateStackInstancesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "CreateStackInstances", {})
     .n("CloudFormationClient", "CreateStackInstancesCommand")
-    .sc(schemas_0.CreateStackInstances$)
+    .sc(CreateStackInstances$)
     .build() {
 }
 
-class CreateStackRefactorCommand extends client.Command
+class CreateStackRefactorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "CreateStackRefactor", {})
     .n("CloudFormationClient", "CreateStackRefactorCommand")
-    .sc(schemas_0.CreateStackRefactor$)
+    .sc(CreateStackRefactor$)
     .build() {
 }
 
-class CreateStackSetCommand extends client.Command
+class CreateStackSetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "CreateStackSet", {})
     .n("CloudFormationClient", "CreateStackSetCommand")
-    .sc(schemas_0.CreateStackSet$)
+    .sc(CreateStackSet$)
     .build() {
 }
 
-class DeactivateOrganizationsAccessCommand extends client.Command
+class DeactivateOrganizationsAccessCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DeactivateOrganizationsAccess", {})
     .n("CloudFormationClient", "DeactivateOrganizationsAccessCommand")
-    .sc(schemas_0.DeactivateOrganizationsAccess$)
+    .sc(DeactivateOrganizationsAccess$)
     .build() {
 }
 
-class DeactivateTypeCommand extends client.Command
+class DeactivateTypeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DeactivateType", {})
     .n("CloudFormationClient", "DeactivateTypeCommand")
-    .sc(schemas_0.DeactivateType$)
+    .sc(DeactivateType$)
     .build() {
 }
 
-class DeleteChangeSetCommand extends client.Command
+class DeleteChangeSetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DeleteChangeSet", {})
     .n("CloudFormationClient", "DeleteChangeSetCommand")
-    .sc(schemas_0.DeleteChangeSet$)
+    .sc(DeleteChangeSet$)
     .build() {
 }
 
-class DeleteGeneratedTemplateCommand extends client.Command
+class DeleteGeneratedTemplateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DeleteGeneratedTemplate", {})
     .n("CloudFormationClient", "DeleteGeneratedTemplateCommand")
-    .sc(schemas_0.DeleteGeneratedTemplate$)
+    .sc(DeleteGeneratedTemplate$)
     .build() {
 }
 
-class DeleteStackCommand extends client.Command
+class DeleteStackCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DeleteStack", {})
     .n("CloudFormationClient", "DeleteStackCommand")
-    .sc(schemas_0.DeleteStack$)
+    .sc(DeleteStack$)
     .build() {
 }
 
-class DeleteStackInstancesCommand extends client.Command
+class DeleteStackInstancesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DeleteStackInstances", {})
     .n("CloudFormationClient", "DeleteStackInstancesCommand")
-    .sc(schemas_0.DeleteStackInstances$)
+    .sc(DeleteStackInstances$)
     .build() {
 }
 
-class DeleteStackSetCommand extends client.Command
+class DeleteStackSetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DeleteStackSet", {})
     .n("CloudFormationClient", "DeleteStackSetCommand")
-    .sc(schemas_0.DeleteStackSet$)
+    .sc(DeleteStackSet$)
     .build() {
 }
 
-class DeregisterTypeCommand extends client.Command
+class DeregisterTypeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DeregisterType", {})
     .n("CloudFormationClient", "DeregisterTypeCommand")
-    .sc(schemas_0.DeregisterType$)
+    .sc(DeregisterType$)
     .build() {
 }
 
-class DescribeAccountLimitsCommand extends client.Command
+class DescribeAccountLimitsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeAccountLimits", {})
     .n("CloudFormationClient", "DescribeAccountLimitsCommand")
-    .sc(schemas_0.DescribeAccountLimits$)
+    .sc(DescribeAccountLimits$)
     .build() {
 }
 
-class DescribeChangeSetCommand extends client.Command
+class DescribeChangeSetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeChangeSet", {})
     .n("CloudFormationClient", "DescribeChangeSetCommand")
-    .sc(schemas_0.DescribeChangeSet$)
+    .sc(DescribeChangeSet$)
     .build() {
 }
 
-class DescribeChangeSetHooksCommand extends client.Command
+class DescribeChangeSetHooksCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeChangeSetHooks", {})
     .n("CloudFormationClient", "DescribeChangeSetHooksCommand")
-    .sc(schemas_0.DescribeChangeSetHooks$)
+    .sc(DescribeChangeSetHooks$)
     .build() {
 }
 
-class DescribeEventsCommand extends client.Command
+class DescribeEventsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeEvents", {})
     .n("CloudFormationClient", "DescribeEventsCommand")
-    .sc(schemas_0.DescribeEvents$)
+    .sc(DescribeEvents$)
     .build() {
 }
 
-class DescribeGeneratedTemplateCommand extends client.Command
+class DescribeGeneratedTemplateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeGeneratedTemplate", {})
     .n("CloudFormationClient", "DescribeGeneratedTemplateCommand")
-    .sc(schemas_0.DescribeGeneratedTemplate$)
+    .sc(DescribeGeneratedTemplate$)
     .build() {
 }
 
-class DescribeOrganizationsAccessCommand extends client.Command
+class DescribeOrganizationsAccessCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeOrganizationsAccess", {})
     .n("CloudFormationClient", "DescribeOrganizationsAccessCommand")
-    .sc(schemas_0.DescribeOrganizationsAccess$)
+    .sc(DescribeOrganizationsAccess$)
     .build() {
 }
 
-class DescribePublisherCommand extends client.Command
+class DescribePublisherCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribePublisher", {})
     .n("CloudFormationClient", "DescribePublisherCommand")
-    .sc(schemas_0.DescribePublisher$)
+    .sc(DescribePublisher$)
     .build() {
 }
 
-class DescribeResourceScanCommand extends client.Command
+class DescribeResourceScanCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeResourceScan", {})
     .n("CloudFormationClient", "DescribeResourceScanCommand")
-    .sc(schemas_0.DescribeResourceScan$)
+    .sc(DescribeResourceScan$)
     .build() {
 }
 
-class DescribeStackDriftDetectionStatusCommand extends client.Command
+class DescribeStackDriftDetectionStatusCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeStackDriftDetectionStatus", {})
     .n("CloudFormationClient", "DescribeStackDriftDetectionStatusCommand")
-    .sc(schemas_0.DescribeStackDriftDetectionStatus$)
+    .sc(DescribeStackDriftDetectionStatus$)
     .build() {
 }
 
-class DescribeStackEventsCommand extends client.Command
+class DescribeStackEventsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeStackEvents", {})
     .n("CloudFormationClient", "DescribeStackEventsCommand")
-    .sc(schemas_0.DescribeStackEvents$)
+    .sc(DescribeStackEvents$)
     .build() {
 }
 
-class DescribeStackInstanceCommand extends client.Command
+class DescribeStackInstanceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeStackInstance", {})
     .n("CloudFormationClient", "DescribeStackInstanceCommand")
-    .sc(schemas_0.DescribeStackInstance$)
+    .sc(DescribeStackInstance$)
     .build() {
 }
 
-class DescribeStackRefactorCommand extends client.Command
+class DescribeStackRefactorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeStackRefactor", {})
     .n("CloudFormationClient", "DescribeStackRefactorCommand")
-    .sc(schemas_0.DescribeStackRefactor$)
+    .sc(DescribeStackRefactor$)
     .build() {
 }
 
-class DescribeStackResourceCommand extends client.Command
+class DescribeStackResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeStackResource", {})
     .n("CloudFormationClient", "DescribeStackResourceCommand")
-    .sc(schemas_0.DescribeStackResource$)
+    .sc(DescribeStackResource$)
     .build() {
 }
 
-class DescribeStackResourceDriftsCommand extends client.Command
+class DescribeStackResourceDriftsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeStackResourceDrifts", {})
     .n("CloudFormationClient", "DescribeStackResourceDriftsCommand")
-    .sc(schemas_0.DescribeStackResourceDrifts$)
+    .sc(DescribeStackResourceDrifts$)
     .build() {
 }
 
-class DescribeStackResourcesCommand extends client.Command
+class DescribeStackResourcesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeStackResources", {})
     .n("CloudFormationClient", "DescribeStackResourcesCommand")
-    .sc(schemas_0.DescribeStackResources$)
+    .sc(DescribeStackResources$)
     .build() {
 }
 
-class DescribeStacksCommand extends client.Command
+class DescribeStacksCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeStacks", {})
     .n("CloudFormationClient", "DescribeStacksCommand")
-    .sc(schemas_0.DescribeStacks$)
+    .sc(DescribeStacks$)
     .build() {
 }
 
-class DescribeStackSetCommand extends client.Command
+class DescribeStackSetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeStackSet", {})
     .n("CloudFormationClient", "DescribeStackSetCommand")
-    .sc(schemas_0.DescribeStackSet$)
+    .sc(DescribeStackSet$)
     .build() {
 }
 
-class DescribeStackSetOperationCommand extends client.Command
+class DescribeStackSetOperationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeStackSetOperation", {})
     .n("CloudFormationClient", "DescribeStackSetOperationCommand")
-    .sc(schemas_0.DescribeStackSetOperation$)
+    .sc(DescribeStackSetOperation$)
     .build() {
 }
 
-class DescribeTypeCommand extends client.Command
+class DescribeTypeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeType", {})
     .n("CloudFormationClient", "DescribeTypeCommand")
-    .sc(schemas_0.DescribeType$)
+    .sc(DescribeType$)
     .build() {
 }
 
-class DescribeTypeRegistrationCommand extends client.Command
+class DescribeTypeRegistrationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DescribeTypeRegistration", {})
     .n("CloudFormationClient", "DescribeTypeRegistrationCommand")
-    .sc(schemas_0.DescribeTypeRegistration$)
+    .sc(DescribeTypeRegistration$)
     .build() {
 }
 
-class DetectStackDriftCommand extends client.Command
+class DetectStackDriftCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DetectStackDrift", {})
     .n("CloudFormationClient", "DetectStackDriftCommand")
-    .sc(schemas_0.DetectStackDrift$)
+    .sc(DetectStackDrift$)
     .build() {
 }
 
-class DetectStackResourceDriftCommand extends client.Command
+class DetectStackResourceDriftCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DetectStackResourceDrift", {})
     .n("CloudFormationClient", "DetectStackResourceDriftCommand")
-    .sc(schemas_0.DetectStackResourceDrift$)
+    .sc(DetectStackResourceDrift$)
     .build() {
 }
 
-class DetectStackSetDriftCommand extends client.Command
+class DetectStackSetDriftCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "DetectStackSetDrift", {})
     .n("CloudFormationClient", "DetectStackSetDriftCommand")
-    .sc(schemas_0.DetectStackSetDrift$)
+    .sc(DetectStackSetDrift$)
     .build() {
 }
 
-class EstimateTemplateCostCommand extends client.Command
+class EstimateTemplateCostCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "EstimateTemplateCost", {})
     .n("CloudFormationClient", "EstimateTemplateCostCommand")
-    .sc(schemas_0.EstimateTemplateCost$)
+    .sc(EstimateTemplateCost$)
     .build() {
 }
 
-class ExecuteChangeSetCommand extends client.Command
+class ExecuteChangeSetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ExecuteChangeSet", {})
     .n("CloudFormationClient", "ExecuteChangeSetCommand")
-    .sc(schemas_0.ExecuteChangeSet$)
+    .sc(ExecuteChangeSet$)
     .build() {
 }
 
-class ExecuteStackRefactorCommand extends client.Command
+class ExecuteStackRefactorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ExecuteStackRefactor", {})
     .n("CloudFormationClient", "ExecuteStackRefactorCommand")
-    .sc(schemas_0.ExecuteStackRefactor$)
+    .sc(ExecuteStackRefactor$)
     .build() {
 }
 
-class GetGeneratedTemplateCommand extends client.Command
+class GetGeneratedTemplateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "GetGeneratedTemplate", {})
     .n("CloudFormationClient", "GetGeneratedTemplateCommand")
-    .sc(schemas_0.GetGeneratedTemplate$)
+    .sc(GetGeneratedTemplate$)
     .build() {
 }
 
-class GetHookResultCommand extends client.Command
+class GetHookResultCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "GetHookResult", {})
     .n("CloudFormationClient", "GetHookResultCommand")
-    .sc(schemas_0.GetHookResult$)
+    .sc(GetHookResult$)
     .build() {
 }
 
-class GetStackPolicyCommand extends client.Command
+class GetStackPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "GetStackPolicy", {})
     .n("CloudFormationClient", "GetStackPolicyCommand")
-    .sc(schemas_0.GetStackPolicy$)
+    .sc(GetStackPolicy$)
     .build() {
 }
 
-class GetTemplateCommand extends client.Command
+class GetTemplateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "GetTemplate", {})
     .n("CloudFormationClient", "GetTemplateCommand")
-    .sc(schemas_0.GetTemplate$)
+    .sc(GetTemplate$)
     .build() {
 }
 
-class GetTemplateSummaryCommand extends client.Command
+class GetTemplateSummaryCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "GetTemplateSummary", {})
     .n("CloudFormationClient", "GetTemplateSummaryCommand")
-    .sc(schemas_0.GetTemplateSummary$)
+    .sc(GetTemplateSummary$)
     .build() {
 }
 
-class ImportStacksToStackSetCommand extends client.Command
+class ImportStacksToStackSetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ImportStacksToStackSet", {})
     .n("CloudFormationClient", "ImportStacksToStackSetCommand")
-    .sc(schemas_0.ImportStacksToStackSet$)
+    .sc(ImportStacksToStackSet$)
     .build() {
 }
 
-class ListChangeSetsCommand extends client.Command
+class ListChangeSetsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListChangeSets", {})
     .n("CloudFormationClient", "ListChangeSetsCommand")
-    .sc(schemas_0.ListChangeSets$)
+    .sc(ListChangeSets$)
     .build() {
 }
 
-class ListExportsCommand extends client.Command
+class ListExportsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListExports", {})
     .n("CloudFormationClient", "ListExportsCommand")
-    .sc(schemas_0.ListExports$)
+    .sc(ListExports$)
     .build() {
 }
 
-class ListGeneratedTemplatesCommand extends client.Command
+class ListGeneratedTemplatesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListGeneratedTemplates", {})
     .n("CloudFormationClient", "ListGeneratedTemplatesCommand")
-    .sc(schemas_0.ListGeneratedTemplates$)
+    .sc(ListGeneratedTemplates$)
     .build() {
 }
 
-class ListHookResultsCommand extends client.Command
+class ListHookResultsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListHookResults", {})
     .n("CloudFormationClient", "ListHookResultsCommand")
-    .sc(schemas_0.ListHookResults$)
+    .sc(ListHookResults$)
     .build() {
 }
 
-class ListImportsCommand extends client.Command
+class ListImportsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListImports", {})
     .n("CloudFormationClient", "ListImportsCommand")
-    .sc(schemas_0.ListImports$)
+    .sc(ListImports$)
     .build() {
 }
 
-class ListResourceScanRelatedResourcesCommand extends client.Command
+class ListResourceScanRelatedResourcesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListResourceScanRelatedResources", {})
     .n("CloudFormationClient", "ListResourceScanRelatedResourcesCommand")
-    .sc(schemas_0.ListResourceScanRelatedResources$)
+    .sc(ListResourceScanRelatedResources$)
     .build() {
 }
 
-class ListResourceScanResourcesCommand extends client.Command
+class ListResourceScanResourcesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListResourceScanResources", {})
     .n("CloudFormationClient", "ListResourceScanResourcesCommand")
-    .sc(schemas_0.ListResourceScanResources$)
+    .sc(ListResourceScanResources$)
     .build() {
 }
 
-class ListResourceScansCommand extends client.Command
+class ListResourceScansCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListResourceScans", {})
     .n("CloudFormationClient", "ListResourceScansCommand")
-    .sc(schemas_0.ListResourceScans$)
+    .sc(ListResourceScans$)
     .build() {
 }
 
-class ListStackInstanceResourceDriftsCommand extends client.Command
+class ListStackInstanceResourceDriftsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListStackInstanceResourceDrifts", {})
     .n("CloudFormationClient", "ListStackInstanceResourceDriftsCommand")
-    .sc(schemas_0.ListStackInstanceResourceDrifts$)
+    .sc(ListStackInstanceResourceDrifts$)
     .build() {
 }
 
-class ListStackInstancesCommand extends client.Command
+class ListStackInstancesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListStackInstances", {})
     .n("CloudFormationClient", "ListStackInstancesCommand")
-    .sc(schemas_0.ListStackInstances$)
+    .sc(ListStackInstances$)
     .build() {
 }
 
-class ListStackRefactorActionsCommand extends client.Command
+class ListStackRefactorActionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListStackRefactorActions", {})
     .n("CloudFormationClient", "ListStackRefactorActionsCommand")
-    .sc(schemas_0.ListStackRefactorActions$)
+    .sc(ListStackRefactorActions$)
     .build() {
 }
 
-class ListStackRefactorsCommand extends client.Command
+class ListStackRefactorsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListStackRefactors", {})
     .n("CloudFormationClient", "ListStackRefactorsCommand")
-    .sc(schemas_0.ListStackRefactors$)
+    .sc(ListStackRefactors$)
     .build() {
 }
 
-class ListStackResourcesCommand extends client.Command
+class ListStackResourcesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListStackResources", {})
     .n("CloudFormationClient", "ListStackResourcesCommand")
-    .sc(schemas_0.ListStackResources$)
+    .sc(ListStackResources$)
     .build() {
 }
 
-class ListStacksCommand extends client.Command
+class ListStacksCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListStacks", {})
     .n("CloudFormationClient", "ListStacksCommand")
-    .sc(schemas_0.ListStacks$)
+    .sc(ListStacks$)
     .build() {
 }
 
-class ListStackSetAutoDeploymentTargetsCommand extends client.Command
+class ListStackSetAutoDeploymentTargetsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListStackSetAutoDeploymentTargets", {})
     .n("CloudFormationClient", "ListStackSetAutoDeploymentTargetsCommand")
-    .sc(schemas_0.ListStackSetAutoDeploymentTargets$)
+    .sc(ListStackSetAutoDeploymentTargets$)
     .build() {
 }
 
-class ListStackSetOperationResultsCommand extends client.Command
+class ListStackSetOperationResultsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListStackSetOperationResults", {})
     .n("CloudFormationClient", "ListStackSetOperationResultsCommand")
-    .sc(schemas_0.ListStackSetOperationResults$)
+    .sc(ListStackSetOperationResults$)
     .build() {
 }
 
-class ListStackSetOperationsCommand extends client.Command
+class ListStackSetOperationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListStackSetOperations", {})
     .n("CloudFormationClient", "ListStackSetOperationsCommand")
-    .sc(schemas_0.ListStackSetOperations$)
+    .sc(ListStackSetOperations$)
     .build() {
 }
 
-class ListStackSetsCommand extends client.Command
+class ListStackSetsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListStackSets", {})
     .n("CloudFormationClient", "ListStackSetsCommand")
-    .sc(schemas_0.ListStackSets$)
+    .sc(ListStackSets$)
     .build() {
 }
 
-class ListTypeRegistrationsCommand extends client.Command
+class ListTypeRegistrationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListTypeRegistrations", {})
     .n("CloudFormationClient", "ListTypeRegistrationsCommand")
-    .sc(schemas_0.ListTypeRegistrations$)
+    .sc(ListTypeRegistrations$)
     .build() {
 }
 
-class ListTypesCommand extends client.Command
+class ListTypesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListTypes", {})
     .n("CloudFormationClient", "ListTypesCommand")
-    .sc(schemas_0.ListTypes$)
+    .sc(ListTypes$)
     .build() {
 }
 
-class ListTypeVersionsCommand extends client.Command
+class ListTypeVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ListTypeVersions", {})
     .n("CloudFormationClient", "ListTypeVersionsCommand")
-    .sc(schemas_0.ListTypeVersions$)
+    .sc(ListTypeVersions$)
     .build() {
 }
 
-class PublishTypeCommand extends client.Command
+class PublishTypeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "PublishType", {})
     .n("CloudFormationClient", "PublishTypeCommand")
-    .sc(schemas_0.PublishType$)
+    .sc(PublishType$)
     .build() {
 }
 
-class RecordHandlerProgressCommand extends client.Command
+class RecordHandlerProgressCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "RecordHandlerProgress", {})
     .n("CloudFormationClient", "RecordHandlerProgressCommand")
-    .sc(schemas_0.RecordHandlerProgress$)
+    .sc(RecordHandlerProgress$)
     .build() {
 }
 
-class RegisterPublisherCommand extends client.Command
+class RegisterPublisherCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "RegisterPublisher", {})
     .n("CloudFormationClient", "RegisterPublisherCommand")
-    .sc(schemas_0.RegisterPublisher$)
+    .sc(RegisterPublisher$)
     .build() {
 }
 
-class RegisterTypeCommand extends client.Command
+class RegisterTypeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "RegisterType", {})
     .n("CloudFormationClient", "RegisterTypeCommand")
-    .sc(schemas_0.RegisterType$)
+    .sc(RegisterType$)
     .build() {
 }
 
-class RollbackStackCommand extends client.Command
+class RollbackStackCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "RollbackStack", {})
     .n("CloudFormationClient", "RollbackStackCommand")
-    .sc(schemas_0.RollbackStack$)
+    .sc(RollbackStack$)
     .build() {
 }
 
-class SetStackPolicyCommand extends client.Command
+class SetStackPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "SetStackPolicy", {})
     .n("CloudFormationClient", "SetStackPolicyCommand")
-    .sc(schemas_0.SetStackPolicy$)
+    .sc(SetStackPolicy$)
     .build() {
 }
 
-class SetTypeConfigurationCommand extends client.Command
+class SetTypeConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "SetTypeConfiguration", {})
     .n("CloudFormationClient", "SetTypeConfigurationCommand")
-    .sc(schemas_0.SetTypeConfiguration$)
+    .sc(SetTypeConfiguration$)
     .build() {
 }
 
-class SetTypeDefaultVersionCommand extends client.Command
+class SetTypeDefaultVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "SetTypeDefaultVersion", {})
     .n("CloudFormationClient", "SetTypeDefaultVersionCommand")
-    .sc(schemas_0.SetTypeDefaultVersion$)
+    .sc(SetTypeDefaultVersion$)
     .build() {
 }
 
-class SignalResourceCommand extends client.Command
+class SignalResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "SignalResource", {})
     .n("CloudFormationClient", "SignalResourceCommand")
-    .sc(schemas_0.SignalResource$)
+    .sc(SignalResource$)
     .build() {
 }
 
-class StartResourceScanCommand extends client.Command
+class StartResourceScanCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "StartResourceScan", {})
     .n("CloudFormationClient", "StartResourceScanCommand")
-    .sc(schemas_0.StartResourceScan$)
+    .sc(StartResourceScan$)
     .build() {
 }
 
-class StopStackSetOperationCommand extends client.Command
+class StopStackSetOperationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "StopStackSetOperation", {})
     .n("CloudFormationClient", "StopStackSetOperationCommand")
-    .sc(schemas_0.StopStackSetOperation$)
+    .sc(StopStackSetOperation$)
     .build() {
 }
 
-class TestTypeCommand extends client.Command
+class TestTypeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "TestType", {})
     .n("CloudFormationClient", "TestTypeCommand")
-    .sc(schemas_0.TestType$)
+    .sc(TestType$)
     .build() {
 }
 
-class UpdateGeneratedTemplateCommand extends client.Command
+class UpdateGeneratedTemplateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "UpdateGeneratedTemplate", {})
     .n("CloudFormationClient", "UpdateGeneratedTemplateCommand")
-    .sc(schemas_0.UpdateGeneratedTemplate$)
+    .sc(UpdateGeneratedTemplate$)
     .build() {
 }
 
-class UpdateStackCommand extends client.Command
+class UpdateStackCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "UpdateStack", {})
     .n("CloudFormationClient", "UpdateStackCommand")
-    .sc(schemas_0.UpdateStack$)
+    .sc(UpdateStack$)
     .build() {
 }
 
-class UpdateStackInstancesCommand extends client.Command
+class UpdateStackInstancesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "UpdateStackInstances", {})
     .n("CloudFormationClient", "UpdateStackInstancesCommand")
-    .sc(schemas_0.UpdateStackInstances$)
+    .sc(UpdateStackInstances$)
     .build() {
 }
 
-class UpdateStackSetCommand extends client.Command
+class UpdateStackSetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "UpdateStackSet", {})
     .n("CloudFormationClient", "UpdateStackSetCommand")
-    .sc(schemas_0.UpdateStackSet$)
+    .sc(UpdateStackSet$)
     .build() {
 }
 
-class UpdateTerminationProtectionCommand extends client.Command
+class UpdateTerminationProtectionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "UpdateTerminationProtection", {})
     .n("CloudFormationClient", "UpdateTerminationProtectionCommand")
-    .sc(schemas_0.UpdateTerminationProtection$)
+    .sc(UpdateTerminationProtection$)
     .build() {
 }
 
-class ValidateTemplateCommand extends client.Command
+class ValidateTemplateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CloudFormation", "ValidateTemplate", {})
     .n("CloudFormationClient", "ValidateTemplateCommand")
-    .sc(schemas_0.ValidateTemplate$)
+    .sc(ValidateTemplate$)
     .build() {
 }
 
-const paginateDescribeAccountLimits = core.createPaginator(CloudFormationClient, DescribeAccountLimitsCommand, "NextToken", "NextToken", "");
+const paginateDescribeAccountLimits = createPaginator(CloudFormationClient, DescribeAccountLimitsCommand, "NextToken", "NextToken", "");
 
-const paginateDescribeChangeSet = core.createPaginator(CloudFormationClient, DescribeChangeSetCommand, "NextToken", "NextToken", "");
+const paginateDescribeChangeSet = createPaginator(CloudFormationClient, DescribeChangeSetCommand, "NextToken", "NextToken", "");
 
-const paginateDescribeEvents = core.createPaginator(CloudFormationClient, DescribeEventsCommand, "NextToken", "NextToken", "");
+const paginateDescribeEvents = createPaginator(CloudFormationClient, DescribeEventsCommand, "NextToken", "NextToken", "");
 
-const paginateDescribeStackEvents = core.createPaginator(CloudFormationClient, DescribeStackEventsCommand, "NextToken", "NextToken", "");
+const paginateDescribeStackEvents = createPaginator(CloudFormationClient, DescribeStackEventsCommand, "NextToken", "NextToken", "");
 
-const paginateDescribeStackResourceDrifts = core.createPaginator(CloudFormationClient, DescribeStackResourceDriftsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateDescribeStackResourceDrifts = createPaginator(CloudFormationClient, DescribeStackResourceDriftsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateDescribeStacks = core.createPaginator(CloudFormationClient, DescribeStacksCommand, "NextToken", "NextToken", "");
+const paginateDescribeStacks = createPaginator(CloudFormationClient, DescribeStacksCommand, "NextToken", "NextToken", "");
 
-const paginateListChangeSets = core.createPaginator(CloudFormationClient, ListChangeSetsCommand, "NextToken", "NextToken", "");
+const paginateListChangeSets = createPaginator(CloudFormationClient, ListChangeSetsCommand, "NextToken", "NextToken", "");
 
-const paginateListExports = core.createPaginator(CloudFormationClient, ListExportsCommand, "NextToken", "NextToken", "");
+const paginateListExports = createPaginator(CloudFormationClient, ListExportsCommand, "NextToken", "NextToken", "");
 
-const paginateListGeneratedTemplates = core.createPaginator(CloudFormationClient, ListGeneratedTemplatesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListGeneratedTemplates = createPaginator(CloudFormationClient, ListGeneratedTemplatesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListImports = core.createPaginator(CloudFormationClient, ListImportsCommand, "NextToken", "NextToken", "");
+const paginateListImports = createPaginator(CloudFormationClient, ListImportsCommand, "NextToken", "NextToken", "");
 
-const paginateListResourceScanRelatedResources = core.createPaginator(CloudFormationClient, ListResourceScanRelatedResourcesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListResourceScanRelatedResources = createPaginator(CloudFormationClient, ListResourceScanRelatedResourcesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListResourceScanResources = core.createPaginator(CloudFormationClient, ListResourceScanResourcesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListResourceScanResources = createPaginator(CloudFormationClient, ListResourceScanResourcesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListResourceScans = core.createPaginator(CloudFormationClient, ListResourceScansCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListResourceScans = createPaginator(CloudFormationClient, ListResourceScansCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListStackInstances = core.createPaginator(CloudFormationClient, ListStackInstancesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListStackInstances = createPaginator(CloudFormationClient, ListStackInstancesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListStackRefactorActions = core.createPaginator(CloudFormationClient, ListStackRefactorActionsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListStackRefactorActions = createPaginator(CloudFormationClient, ListStackRefactorActionsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListStackRefactors = core.createPaginator(CloudFormationClient, ListStackRefactorsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListStackRefactors = createPaginator(CloudFormationClient, ListStackRefactorsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListStackResources = core.createPaginator(CloudFormationClient, ListStackResourcesCommand, "NextToken", "NextToken", "");
+const paginateListStackResources = createPaginator(CloudFormationClient, ListStackResourcesCommand, "NextToken", "NextToken", "");
 
-const paginateListStackSetOperationResults = core.createPaginator(CloudFormationClient, ListStackSetOperationResultsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListStackSetOperationResults = createPaginator(CloudFormationClient, ListStackSetOperationResultsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListStackSetOperations = core.createPaginator(CloudFormationClient, ListStackSetOperationsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListStackSetOperations = createPaginator(CloudFormationClient, ListStackSetOperationsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListStackSets = core.createPaginator(CloudFormationClient, ListStackSetsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListStackSets = createPaginator(CloudFormationClient, ListStackSetsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListStacks = core.createPaginator(CloudFormationClient, ListStacksCommand, "NextToken", "NextToken", "");
+const paginateListStacks = createPaginator(CloudFormationClient, ListStacksCommand, "NextToken", "NextToken", "");
 
-const paginateListTypeRegistrations = core.createPaginator(CloudFormationClient, ListTypeRegistrationsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListTypeRegistrations = createPaginator(CloudFormationClient, ListTypeRegistrationsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListTypes = core.createPaginator(CloudFormationClient, ListTypesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListTypes = createPaginator(CloudFormationClient, ListTypesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListTypeVersions = core.createPaginator(CloudFormationClient, ListTypeVersionsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListTypeVersions = createPaginator(CloudFormationClient, ListTypeVersionsCommand, "NextToken", "NextToken", "MaxResults");
 
-const checkState$9 = async (client$1, input) => {
+const checkState$9 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeChangeSetCommand(input));
+        let result = await client.send(new DescribeChangeSetCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.Status;
             };
             if (returnComparator() === "CREATE_COMPLETE") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1259,7 +1258,7 @@ const checkState$9 = async (client$1, input) => {
                 return result.Status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1267,25 +1266,25 @@ const checkState$9 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ValidationError") {
-            return { state: client.WaiterState.FAILURE, reason };
+            return { state: WaiterState.FAILURE, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForChangeSetCreateComplete = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
+    return 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 result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
+    return checkExceptions(result);
 };
 
-const checkState$8 = async (client$1, input) => {
+const checkState$8 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeStacksCommand(input));
+        let result = await client.send(new DescribeStacksCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -1300,7 +1299,7 @@ const checkState$8 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "CREATE_COMPLETE");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1317,7 +1316,7 @@ const checkState$8 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_COMPLETE");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1334,7 +1333,7 @@ const checkState$8 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_IN_PROGRESS");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1351,7 +1350,7 @@ const checkState$8 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1368,7 +1367,7 @@ const checkState$8 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_FAILED");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1385,7 +1384,7 @@ const checkState$8 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_ROLLBACK_IN_PROGRESS");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1402,7 +1401,7 @@ const checkState$8 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_ROLLBACK_FAILED");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1419,7 +1418,7 @@ const checkState$8 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1436,7 +1435,7 @@ const checkState$8 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_ROLLBACK_COMPLETE");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1450,7 +1449,7 @@ const checkState$8 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "CREATE_FAILED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1465,7 +1464,7 @@ const checkState$8 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "DELETE_COMPLETE") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1480,7 +1479,7 @@ const checkState$8 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "DELETE_FAILED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1495,7 +1494,7 @@ const checkState$8 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "ROLLBACK_FAILED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1510,7 +1509,7 @@ const checkState$8 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "ROLLBACK_COMPLETE") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1519,25 +1518,25 @@ const checkState$8 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ValidationError") {
-            return { state: client.WaiterState.FAILURE, reason };
+            return { state: WaiterState.FAILURE, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForStackCreateComplete = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
+    return 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 result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
+    return checkExceptions(result);
 };
 
-const checkState$7 = async (client$1, input) => {
+const checkState$7 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeStacksCommand(input));
+        let result = await client.send(new DescribeStacksCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -1552,7 +1551,7 @@ const checkState$7 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "DELETE_COMPLETE");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1566,7 +1565,7 @@ const checkState$7 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "DELETE_FAILED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1581,7 +1580,7 @@ const checkState$7 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "CREATE_FAILED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1596,7 +1595,7 @@ const checkState$7 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "ROLLBACK_FAILED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1611,7 +1610,7 @@ const checkState$7 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "UPDATE_ROLLBACK_IN_PROGRESS") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1626,7 +1625,7 @@ const checkState$7 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "UPDATE_ROLLBACK_FAILED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1641,7 +1640,7 @@ const checkState$7 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "UPDATE_ROLLBACK_COMPLETE") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1656,7 +1655,7 @@ const checkState$7 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "UPDATE_COMPLETE") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1665,50 +1664,50 @@ const checkState$7 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ValidationError") {
-            return { state: client.WaiterState.SUCCESS, reason };
+            return { state: WaiterState.SUCCESS, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForStackDeleteComplete = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
+    return 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 result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
+    return checkExceptions(result);
 };
 
-const checkState$6 = async (client$1, input) => {
+const checkState$6 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeStacksCommand(input));
+        let result = await client.send(new DescribeStacksCommand(input));
         reason = result;
-        return { state: client.WaiterState.SUCCESS, reason };
+        return { state: WaiterState.SUCCESS, reason };
     }
     catch (exception) {
         reason = exception;
         if (exception.name === "ValidationError") {
-            return { state: client.WaiterState.RETRY, reason };
+            return { state: WaiterState.RETRY, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForStackExists = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
+    return 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 result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
+    return checkExceptions(result);
 };
 
-const checkState$5 = async (client$1, input) => {
+const checkState$5 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeStacksCommand(input));
+        let result = await client.send(new DescribeStacksCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -1723,7 +1722,7 @@ const checkState$5 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "IMPORT_COMPLETE");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1737,7 +1736,7 @@ const checkState$5 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "ROLLBACK_COMPLETE") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1752,7 +1751,7 @@ const checkState$5 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "ROLLBACK_FAILED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1767,7 +1766,7 @@ const checkState$5 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "IMPORT_ROLLBACK_IN_PROGRESS") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1782,7 +1781,7 @@ const checkState$5 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "IMPORT_ROLLBACK_FAILED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1797,7 +1796,7 @@ const checkState$5 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "IMPORT_ROLLBACK_COMPLETE") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1806,32 +1805,32 @@ const checkState$5 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ValidationError") {
-            return { state: client.WaiterState.FAILURE, reason };
+            return { state: WaiterState.FAILURE, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForStackImportComplete = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return 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 result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return checkExceptions(result);
 };
 
-const checkState$4 = async (client$1, input) => {
+const checkState$4 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeStackRefactorCommand(input));
+        let result = await client.send(new DescribeStackRefactorCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.Status;
             };
             if (returnComparator() === "CREATE_COMPLETE") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1840,7 +1839,7 @@ const checkState$4 = async (client$1, input) => {
                 return result.Status;
             };
             if (returnComparator() === "CREATE_FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1848,32 +1847,32 @@ const checkState$4 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ValidationError") {
-            return { state: client.WaiterState.FAILURE, reason };
+            return { state: WaiterState.FAILURE, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForStackRefactorCreateComplete = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return 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 result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return checkExceptions(result);
 };
 
-const checkState$3 = async (client$1, input) => {
+const checkState$3 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeStackRefactorCommand(input));
+        let result = await client.send(new DescribeStackRefactorCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.ExecutionStatus;
             };
             if (returnComparator() === "EXECUTE_COMPLETE") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1882,7 +1881,7 @@ const checkState$3 = async (client$1, input) => {
                 return result.ExecutionStatus;
             };
             if (returnComparator() === "EXECUTE_FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1891,7 +1890,7 @@ const checkState$3 = async (client$1, input) => {
                 return result.ExecutionStatus;
             };
             if (returnComparator() === "ROLLBACK_COMPLETE") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1899,25 +1898,25 @@ const checkState$3 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ValidationError") {
-            return { state: client.WaiterState.FAILURE, reason };
+            return { state: WaiterState.FAILURE, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForStackRefactorExecuteComplete = async (params, input) => {
     const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return 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 result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return checkExceptions(result);
 };
 
-const checkState$2 = async (client$1, input) => {
+const checkState$2 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeStacksCommand(input));
+        let result = await client.send(new DescribeStacksCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -1932,7 +1931,7 @@ const checkState$2 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_ROLLBACK_COMPLETE");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1946,7 +1945,7 @@ const checkState$2 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "UPDATE_FAILED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1961,7 +1960,7 @@ const checkState$2 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "UPDATE_ROLLBACK_FAILED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1976,7 +1975,7 @@ const checkState$2 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "DELETE_FAILED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1985,25 +1984,25 @@ const checkState$2 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ValidationError") {
-            return { state: client.WaiterState.FAILURE, reason };
+            return { state: WaiterState.FAILURE, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForStackRollbackComplete = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return 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 result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return checkExceptions(result);
 };
 
-const checkState$1 = async (client$1, input) => {
+const checkState$1 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeStacksCommand(input));
+        let result = await client.send(new DescribeStacksCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -2018,7 +2017,7 @@ const checkState$1 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "UPDATE_COMPLETE");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2032,7 +2031,7 @@ const checkState$1 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "UPDATE_FAILED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2047,7 +2046,7 @@ const checkState$1 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "UPDATE_ROLLBACK_FAILED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2062,7 +2061,7 @@ const checkState$1 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "UPDATE_ROLLBACK_COMPLETE") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2071,32 +2070,32 @@ const checkState$1 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ValidationError") {
-            return { state: client.WaiterState.FAILURE, reason };
+            return { state: WaiterState.FAILURE, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForStackUpdateComplete = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return 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 result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return checkExceptions(result);
 };
 
-const checkState = async (client$1, input) => {
+const checkState = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeTypeRegistrationCommand(input));
+        let result = await client.send(new DescribeTypeRegistrationCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.ProgressStatus;
             };
             if (returnComparator() === "COMPLETE") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2105,7 +2104,7 @@ const checkState = async (client$1, input) => {
                 return result.ProgressStatus;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2113,16 +2112,16 @@ const checkState = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForTypeRegistrationComplete = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return 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 result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
 };
 
 const commands = {
@@ -2257,7 +2256,7 @@ const waiters = {
 };
 class CloudFormation extends CloudFormationClient {
 }
-client.createAggregatedClient(commands, CloudFormation, { paginators, waiters });
+createAggregatedClient(commands, CloudFormation, { paginators, waiters });
 
 const AccountFilterType = {
     DIFFERENCE: "DIFFERENCE",
@@ -2780,9 +2779,6 @@ const ResourceSignalStatus = {
     SUCCESS: "SUCCESS",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.CloudFormationServiceException = CloudFormationServiceException.CloudFormationServiceException;
 exports.AccountFilterType = AccountFilterType;
 exports.AccountGateStatus = AccountGateStatus;
 exports.ActivateOrganizationsAccessCommand = ActivateOrganizationsAccessCommand;
@@ -3004,23 +3000,3 @@ exports.waitUntilStackRefactorExecuteComplete = waitUntilStackRefactorExecuteCom
 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];
-});