@aws-sdk/client-ecs 3.1067.0 → 3.1069.0

package/dist-cjs/index.js

@@ -1,18 +1,21 @@
-'use strict';
-
-var client$1 = require('@aws-sdk/core/client');
-var core = require('@smithy/core');
-var client = require('@smithy/core/client');
-var config = require('@smithy/core/config');
-var endpoints = require('@smithy/core/endpoints');
-var protocols = require('@smithy/core/protocols');
-var retry = require('@smithy/core/retry');
-var schema = require('@smithy/core/schema');
-var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
-var runtimeConfig = require('./runtimeConfig');
-var schemas_0 = require('./schemas/schemas_0');
-var errors = require('./models/errors');
-var ECSServiceException = require('./models/ECSServiceException');
+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, defaultECSHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { ContinueServiceDeployment$, CreateCapacityProvider$, CreateCluster$, CreateDaemon$, CreateExpressGatewayService$, CreateService$, CreateTaskSet$, DeleteAccountSetting$, DeleteAttributes$, DeleteCapacityProvider$, DeleteCluster$, DeleteDaemon$, DeleteDaemonTaskDefinition$, DeleteExpressGatewayService$, DeleteService$, DeleteTaskDefinitions$, DeleteTaskSet$, DeregisterContainerInstance$, DeregisterTaskDefinition$, DescribeCapacityProviders$, DescribeClusters$, DescribeContainerInstances$, DescribeDaemon$, DescribeDaemonDeployments$, DescribeDaemonRevisions$, DescribeDaemonTaskDefinition$, DescribeExpressGatewayService$, DescribeServiceDeployments$, DescribeServiceRevisions$, DescribeServices$, DescribeTaskDefinition$, DescribeTasks$, DescribeTaskSets$, DiscoverPollEndpoint$, ExecuteCommand$, GetTaskProtection$, ListAccountSettings$, ListAttributes$, ListClusters$, ListContainerInstances$, ListDaemonDeployments$, ListDaemons$, ListDaemonTaskDefinitions$, ListServiceDeployments$, ListServicesByNamespace$, ListServices$, ListTagsForResource$, ListTaskDefinitionFamilies$, ListTaskDefinitions$, ListTasks$, PutAccountSetting$, PutAccountSettingDefault$, PutAttributes$, PutClusterCapacityProviders$, RegisterContainerInstance$, RegisterDaemonTaskDefinition$, RegisterTaskDefinition$, RunTask$, StartTask$, StopServiceDeployment$, StopTask$, SubmitAttachmentStateChanges$, SubmitContainerStateChange$, SubmitTaskStateChange$, TagResource$, UntagResource$, UpdateCapacityProvider$, UpdateCluster$, UpdateClusterSettings$, UpdateContainerAgent$, UpdateContainerInstancesState$, UpdateDaemon$, UpdateExpressGatewayService$, UpdateService$, UpdateServicePrimaryTaskSet$, UpdateTaskProtection$, UpdateTaskSet$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+__exportStar(require("./models/errors"), exports);
+const { ECSServiceException } = require("./models/ECSServiceException");
+exports.ECSServiceException = ECSServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -68,999 +71,999 @@ const resolveHttpAuthRuntimeConfig = (config) => {
 };
 
 const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const extensionConfiguration = Object.assign(client$1.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, client$1.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+    return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
 };
 
-class ECSClient extends client.Client {
+class ECSClient 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 = client$1.resolveUserAgentConfig(_config_1);
-        const _config_3 = retry.resolveRetryConfig(_config_2);
-        const _config_4 = config.resolveRegionConfig(_config_3);
-        const _config_5 = client$1.resolveHostHeaderConfig(_config_4);
-        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
-        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_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(client$1.getUserAgentPlugin(this.config));
-        this.middlewareStack.use(retry.getRetryPlugin(this.config));
-        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
-        this.middlewareStack.use(client$1.getHostHeaderPlugin(this.config));
-        this.middlewareStack.use(client$1.getLoggerPlugin(this.config));
-        this.middlewareStack.use(client$1.getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
-            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultECSHttpAuthSchemeParametersProvider,
-            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: defaultECSHttpAuthSchemeParametersProvider,
+            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 ContinueServiceDeploymentCommand extends client.Command
+class ContinueServiceDeploymentCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "ContinueServiceDeployment", {})
     .n("ECSClient", "ContinueServiceDeploymentCommand")
-    .sc(schemas_0.ContinueServiceDeployment$)
+    .sc(ContinueServiceDeployment$)
     .build() {
 }
 
-class CreateCapacityProviderCommand extends client.Command
+class CreateCapacityProviderCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "CreateCapacityProvider", {})
     .n("ECSClient", "CreateCapacityProviderCommand")
-    .sc(schemas_0.CreateCapacityProvider$)
+    .sc(CreateCapacityProvider$)
     .build() {
 }
 
-class CreateClusterCommand extends client.Command
+class CreateClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "CreateCluster", {})
     .n("ECSClient", "CreateClusterCommand")
-    .sc(schemas_0.CreateCluster$)
+    .sc(CreateCluster$)
     .build() {
 }
 
-class CreateDaemonCommand extends client.Command
+class CreateDaemonCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "CreateDaemon", {})
     .n("ECSClient", "CreateDaemonCommand")
-    .sc(schemas_0.CreateDaemon$)
+    .sc(CreateDaemon$)
     .build() {
 }
 
-class CreateExpressGatewayServiceCommand extends client.Command
+class CreateExpressGatewayServiceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "CreateExpressGatewayService", {})
     .n("ECSClient", "CreateExpressGatewayServiceCommand")
-    .sc(schemas_0.CreateExpressGatewayService$)
+    .sc(CreateExpressGatewayService$)
     .build() {
 }
 
-class CreateServiceCommand extends client.Command
+class CreateServiceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "CreateService", {})
     .n("ECSClient", "CreateServiceCommand")
-    .sc(schemas_0.CreateService$)
+    .sc(CreateService$)
     .build() {
 }
 
-class CreateTaskSetCommand extends client.Command
+class CreateTaskSetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "CreateTaskSet", {})
     .n("ECSClient", "CreateTaskSetCommand")
-    .sc(schemas_0.CreateTaskSet$)
+    .sc(CreateTaskSet$)
     .build() {
 }
 
-class DeleteAccountSettingCommand extends client.Command
+class DeleteAccountSettingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DeleteAccountSetting", {})
     .n("ECSClient", "DeleteAccountSettingCommand")
-    .sc(schemas_0.DeleteAccountSetting$)
+    .sc(DeleteAccountSetting$)
     .build() {
 }
 
-class DeleteAttributesCommand extends client.Command
+class DeleteAttributesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DeleteAttributes", {})
     .n("ECSClient", "DeleteAttributesCommand")
-    .sc(schemas_0.DeleteAttributes$)
+    .sc(DeleteAttributes$)
     .build() {
 }
 
-class DeleteCapacityProviderCommand extends client.Command
+class DeleteCapacityProviderCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DeleteCapacityProvider", {})
     .n("ECSClient", "DeleteCapacityProviderCommand")
-    .sc(schemas_0.DeleteCapacityProvider$)
+    .sc(DeleteCapacityProvider$)
     .build() {
 }
 
-class DeleteClusterCommand extends client.Command
+class DeleteClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DeleteCluster", {})
     .n("ECSClient", "DeleteClusterCommand")
-    .sc(schemas_0.DeleteCluster$)
+    .sc(DeleteCluster$)
     .build() {
 }
 
-class DeleteDaemonCommand extends client.Command
+class DeleteDaemonCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DeleteDaemon", {})
     .n("ECSClient", "DeleteDaemonCommand")
-    .sc(schemas_0.DeleteDaemon$)
+    .sc(DeleteDaemon$)
     .build() {
 }
 
-class DeleteDaemonTaskDefinitionCommand extends client.Command
+class DeleteDaemonTaskDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DeleteDaemonTaskDefinition", {})
     .n("ECSClient", "DeleteDaemonTaskDefinitionCommand")
-    .sc(schemas_0.DeleteDaemonTaskDefinition$)
+    .sc(DeleteDaemonTaskDefinition$)
     .build() {
 }
 
-class DeleteExpressGatewayServiceCommand extends client.Command
+class DeleteExpressGatewayServiceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DeleteExpressGatewayService", {})
     .n("ECSClient", "DeleteExpressGatewayServiceCommand")
-    .sc(schemas_0.DeleteExpressGatewayService$)
+    .sc(DeleteExpressGatewayService$)
     .build() {
 }
 
-class DeleteServiceCommand extends client.Command
+class DeleteServiceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DeleteService", {})
     .n("ECSClient", "DeleteServiceCommand")
-    .sc(schemas_0.DeleteService$)
+    .sc(DeleteService$)
     .build() {
 }
 
-class DeleteTaskDefinitionsCommand extends client.Command
+class DeleteTaskDefinitionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DeleteTaskDefinitions", {})
     .n("ECSClient", "DeleteTaskDefinitionsCommand")
-    .sc(schemas_0.DeleteTaskDefinitions$)
+    .sc(DeleteTaskDefinitions$)
     .build() {
 }
 
-class DeleteTaskSetCommand extends client.Command
+class DeleteTaskSetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DeleteTaskSet", {})
     .n("ECSClient", "DeleteTaskSetCommand")
-    .sc(schemas_0.DeleteTaskSet$)
+    .sc(DeleteTaskSet$)
     .build() {
 }
 
-class DeregisterContainerInstanceCommand extends client.Command
+class DeregisterContainerInstanceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DeregisterContainerInstance", {})
     .n("ECSClient", "DeregisterContainerInstanceCommand")
-    .sc(schemas_0.DeregisterContainerInstance$)
+    .sc(DeregisterContainerInstance$)
     .build() {
 }
 
-class DeregisterTaskDefinitionCommand extends client.Command
+class DeregisterTaskDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DeregisterTaskDefinition", {})
     .n("ECSClient", "DeregisterTaskDefinitionCommand")
-    .sc(schemas_0.DeregisterTaskDefinition$)
+    .sc(DeregisterTaskDefinition$)
     .build() {
 }
 
-class DescribeCapacityProvidersCommand extends client.Command
+class DescribeCapacityProvidersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DescribeCapacityProviders", {})
     .n("ECSClient", "DescribeCapacityProvidersCommand")
-    .sc(schemas_0.DescribeCapacityProviders$)
+    .sc(DescribeCapacityProviders$)
     .build() {
 }
 
-class DescribeClustersCommand extends client.Command
+class DescribeClustersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DescribeClusters", {})
     .n("ECSClient", "DescribeClustersCommand")
-    .sc(schemas_0.DescribeClusters$)
+    .sc(DescribeClusters$)
     .build() {
 }
 
-class DescribeContainerInstancesCommand extends client.Command
+class DescribeContainerInstancesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DescribeContainerInstances", {})
     .n("ECSClient", "DescribeContainerInstancesCommand")
-    .sc(schemas_0.DescribeContainerInstances$)
+    .sc(DescribeContainerInstances$)
     .build() {
 }
 
-class DescribeDaemonCommand extends client.Command
+class DescribeDaemonCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DescribeDaemon", {})
     .n("ECSClient", "DescribeDaemonCommand")
-    .sc(schemas_0.DescribeDaemon$)
+    .sc(DescribeDaemon$)
     .build() {
 }
 
-class DescribeDaemonDeploymentsCommand extends client.Command
+class DescribeDaemonDeploymentsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DescribeDaemonDeployments", {})
     .n("ECSClient", "DescribeDaemonDeploymentsCommand")
-    .sc(schemas_0.DescribeDaemonDeployments$)
+    .sc(DescribeDaemonDeployments$)
     .build() {
 }
 
-class DescribeDaemonRevisionsCommand extends client.Command
+class DescribeDaemonRevisionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DescribeDaemonRevisions", {})
     .n("ECSClient", "DescribeDaemonRevisionsCommand")
-    .sc(schemas_0.DescribeDaemonRevisions$)
+    .sc(DescribeDaemonRevisions$)
     .build() {
 }
 
-class DescribeDaemonTaskDefinitionCommand extends client.Command
+class DescribeDaemonTaskDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DescribeDaemonTaskDefinition", {})
     .n("ECSClient", "DescribeDaemonTaskDefinitionCommand")
-    .sc(schemas_0.DescribeDaemonTaskDefinition$)
+    .sc(DescribeDaemonTaskDefinition$)
     .build() {
 }
 
-class DescribeExpressGatewayServiceCommand extends client.Command
+class DescribeExpressGatewayServiceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DescribeExpressGatewayService", {})
     .n("ECSClient", "DescribeExpressGatewayServiceCommand")
-    .sc(schemas_0.DescribeExpressGatewayService$)
+    .sc(DescribeExpressGatewayService$)
     .build() {
 }
 
-class DescribeServiceDeploymentsCommand extends client.Command
+class DescribeServiceDeploymentsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DescribeServiceDeployments", {})
     .n("ECSClient", "DescribeServiceDeploymentsCommand")
-    .sc(schemas_0.DescribeServiceDeployments$)
+    .sc(DescribeServiceDeployments$)
     .build() {
 }
 
-class DescribeServiceRevisionsCommand extends client.Command
+class DescribeServiceRevisionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DescribeServiceRevisions", {})
     .n("ECSClient", "DescribeServiceRevisionsCommand")
-    .sc(schemas_0.DescribeServiceRevisions$)
+    .sc(DescribeServiceRevisions$)
     .build() {
 }
 
-class DescribeServicesCommand extends client.Command
+class DescribeServicesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DescribeServices", {})
     .n("ECSClient", "DescribeServicesCommand")
-    .sc(schemas_0.DescribeServices$)
+    .sc(DescribeServices$)
     .build() {
 }
 
-class DescribeTaskDefinitionCommand extends client.Command
+class DescribeTaskDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DescribeTaskDefinition", {})
     .n("ECSClient", "DescribeTaskDefinitionCommand")
-    .sc(schemas_0.DescribeTaskDefinition$)
+    .sc(DescribeTaskDefinition$)
     .build() {
 }
 
-class DescribeTasksCommand extends client.Command
+class DescribeTasksCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DescribeTasks", {})
     .n("ECSClient", "DescribeTasksCommand")
-    .sc(schemas_0.DescribeTasks$)
+    .sc(DescribeTasks$)
     .build() {
 }
 
-class DescribeTaskSetsCommand extends client.Command
+class DescribeTaskSetsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DescribeTaskSets", {})
     .n("ECSClient", "DescribeTaskSetsCommand")
-    .sc(schemas_0.DescribeTaskSets$)
+    .sc(DescribeTaskSets$)
     .build() {
 }
 
-class DiscoverPollEndpointCommand extends client.Command
+class DiscoverPollEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "DiscoverPollEndpoint", {})
     .n("ECSClient", "DiscoverPollEndpointCommand")
-    .sc(schemas_0.DiscoverPollEndpoint$)
+    .sc(DiscoverPollEndpoint$)
     .build() {
 }
 
-class ExecuteCommandCommand extends client.Command
+class ExecuteCommandCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "ExecuteCommand", {})
     .n("ECSClient", "ExecuteCommandCommand")
-    .sc(schemas_0.ExecuteCommand$)
+    .sc(ExecuteCommand$)
     .build() {
 }
 
-class GetTaskProtectionCommand extends client.Command
+class GetTaskProtectionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "GetTaskProtection", {})
     .n("ECSClient", "GetTaskProtectionCommand")
-    .sc(schemas_0.GetTaskProtection$)
+    .sc(GetTaskProtection$)
     .build() {
 }
 
-class ListAccountSettingsCommand extends client.Command
+class ListAccountSettingsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "ListAccountSettings", {})
     .n("ECSClient", "ListAccountSettingsCommand")
-    .sc(schemas_0.ListAccountSettings$)
+    .sc(ListAccountSettings$)
     .build() {
 }
 
-class ListAttributesCommand extends client.Command
+class ListAttributesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "ListAttributes", {})
     .n("ECSClient", "ListAttributesCommand")
-    .sc(schemas_0.ListAttributes$)
+    .sc(ListAttributes$)
     .build() {
 }
 
-class ListClustersCommand extends client.Command
+class ListClustersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "ListClusters", {})
     .n("ECSClient", "ListClustersCommand")
-    .sc(schemas_0.ListClusters$)
+    .sc(ListClusters$)
     .build() {
 }
 
-class ListContainerInstancesCommand extends client.Command
+class ListContainerInstancesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "ListContainerInstances", {})
     .n("ECSClient", "ListContainerInstancesCommand")
-    .sc(schemas_0.ListContainerInstances$)
+    .sc(ListContainerInstances$)
     .build() {
 }
 
-class ListDaemonDeploymentsCommand extends client.Command
+class ListDaemonDeploymentsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "ListDaemonDeployments", {})
     .n("ECSClient", "ListDaemonDeploymentsCommand")
-    .sc(schemas_0.ListDaemonDeployments$)
+    .sc(ListDaemonDeployments$)
     .build() {
 }
 
-class ListDaemonsCommand extends client.Command
+class ListDaemonsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "ListDaemons", {})
     .n("ECSClient", "ListDaemonsCommand")
-    .sc(schemas_0.ListDaemons$)
+    .sc(ListDaemons$)
     .build() {
 }
 
-class ListDaemonTaskDefinitionsCommand extends client.Command
+class ListDaemonTaskDefinitionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "ListDaemonTaskDefinitions", {})
     .n("ECSClient", "ListDaemonTaskDefinitionsCommand")
-    .sc(schemas_0.ListDaemonTaskDefinitions$)
+    .sc(ListDaemonTaskDefinitions$)
     .build() {
 }
 
-class ListServiceDeploymentsCommand extends client.Command
+class ListServiceDeploymentsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "ListServiceDeployments", {})
     .n("ECSClient", "ListServiceDeploymentsCommand")
-    .sc(schemas_0.ListServiceDeployments$)
+    .sc(ListServiceDeployments$)
     .build() {
 }
 
-class ListServicesByNamespaceCommand extends client.Command
+class ListServicesByNamespaceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "ListServicesByNamespace", {})
     .n("ECSClient", "ListServicesByNamespaceCommand")
-    .sc(schemas_0.ListServicesByNamespace$)
+    .sc(ListServicesByNamespace$)
     .build() {
 }
 
-class ListServicesCommand extends client.Command
+class ListServicesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "ListServices", {})
     .n("ECSClient", "ListServicesCommand")
-    .sc(schemas_0.ListServices$)
+    .sc(ListServices$)
     .build() {
 }
 
-class ListTagsForResourceCommand extends client.Command
+class ListTagsForResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "ListTagsForResource", {})
     .n("ECSClient", "ListTagsForResourceCommand")
-    .sc(schemas_0.ListTagsForResource$)
+    .sc(ListTagsForResource$)
     .build() {
 }
 
-class ListTaskDefinitionFamiliesCommand extends client.Command
+class ListTaskDefinitionFamiliesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "ListTaskDefinitionFamilies", {})
     .n("ECSClient", "ListTaskDefinitionFamiliesCommand")
-    .sc(schemas_0.ListTaskDefinitionFamilies$)
+    .sc(ListTaskDefinitionFamilies$)
     .build() {
 }
 
-class ListTaskDefinitionsCommand extends client.Command
+class ListTaskDefinitionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "ListTaskDefinitions", {})
     .n("ECSClient", "ListTaskDefinitionsCommand")
-    .sc(schemas_0.ListTaskDefinitions$)
+    .sc(ListTaskDefinitions$)
     .build() {
 }
 
-class ListTasksCommand extends client.Command
+class ListTasksCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "ListTasks", {})
     .n("ECSClient", "ListTasksCommand")
-    .sc(schemas_0.ListTasks$)
+    .sc(ListTasks$)
     .build() {
 }
 
-class PutAccountSettingCommand extends client.Command
+class PutAccountSettingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "PutAccountSetting", {})
     .n("ECSClient", "PutAccountSettingCommand")
-    .sc(schemas_0.PutAccountSetting$)
+    .sc(PutAccountSetting$)
     .build() {
 }
 
-class PutAccountSettingDefaultCommand extends client.Command
+class PutAccountSettingDefaultCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "PutAccountSettingDefault", {})
     .n("ECSClient", "PutAccountSettingDefaultCommand")
-    .sc(schemas_0.PutAccountSettingDefault$)
+    .sc(PutAccountSettingDefault$)
     .build() {
 }
 
-class PutAttributesCommand extends client.Command
+class PutAttributesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "PutAttributes", {})
     .n("ECSClient", "PutAttributesCommand")
-    .sc(schemas_0.PutAttributes$)
+    .sc(PutAttributes$)
     .build() {
 }
 
-class PutClusterCapacityProvidersCommand extends client.Command
+class PutClusterCapacityProvidersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "PutClusterCapacityProviders", {})
     .n("ECSClient", "PutClusterCapacityProvidersCommand")
-    .sc(schemas_0.PutClusterCapacityProviders$)
+    .sc(PutClusterCapacityProviders$)
     .build() {
 }
 
-class RegisterContainerInstanceCommand extends client.Command
+class RegisterContainerInstanceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "RegisterContainerInstance", {})
     .n("ECSClient", "RegisterContainerInstanceCommand")
-    .sc(schemas_0.RegisterContainerInstance$)
+    .sc(RegisterContainerInstance$)
     .build() {
 }
 
-class RegisterDaemonTaskDefinitionCommand extends client.Command
+class RegisterDaemonTaskDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "RegisterDaemonTaskDefinition", {})
     .n("ECSClient", "RegisterDaemonTaskDefinitionCommand")
-    .sc(schemas_0.RegisterDaemonTaskDefinition$)
+    .sc(RegisterDaemonTaskDefinition$)
     .build() {
 }
 
-class RegisterTaskDefinitionCommand extends client.Command
+class RegisterTaskDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "RegisterTaskDefinition", {})
     .n("ECSClient", "RegisterTaskDefinitionCommand")
-    .sc(schemas_0.RegisterTaskDefinition$)
+    .sc(RegisterTaskDefinition$)
     .build() {
 }
 
-class RunTaskCommand extends client.Command
+class RunTaskCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "RunTask", {})
     .n("ECSClient", "RunTaskCommand")
-    .sc(schemas_0.RunTask$)
+    .sc(RunTask$)
     .build() {
 }
 
-class StartTaskCommand extends client.Command
+class StartTaskCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "StartTask", {})
     .n("ECSClient", "StartTaskCommand")
-    .sc(schemas_0.StartTask$)
+    .sc(StartTask$)
     .build() {
 }
 
-class StopServiceDeploymentCommand extends client.Command
+class StopServiceDeploymentCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "StopServiceDeployment", {})
     .n("ECSClient", "StopServiceDeploymentCommand")
-    .sc(schemas_0.StopServiceDeployment$)
+    .sc(StopServiceDeployment$)
     .build() {
 }
 
-class StopTaskCommand extends client.Command
+class StopTaskCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "StopTask", {})
     .n("ECSClient", "StopTaskCommand")
-    .sc(schemas_0.StopTask$)
+    .sc(StopTask$)
     .build() {
 }
 
-class SubmitAttachmentStateChangesCommand extends client.Command
+class SubmitAttachmentStateChangesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "SubmitAttachmentStateChanges", {})
     .n("ECSClient", "SubmitAttachmentStateChangesCommand")
-    .sc(schemas_0.SubmitAttachmentStateChanges$)
+    .sc(SubmitAttachmentStateChanges$)
     .build() {
 }
 
-class SubmitContainerStateChangeCommand extends client.Command
+class SubmitContainerStateChangeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "SubmitContainerStateChange", {})
     .n("ECSClient", "SubmitContainerStateChangeCommand")
-    .sc(schemas_0.SubmitContainerStateChange$)
+    .sc(SubmitContainerStateChange$)
     .build() {
 }
 
-class SubmitTaskStateChangeCommand extends client.Command
+class SubmitTaskStateChangeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "SubmitTaskStateChange", {})
     .n("ECSClient", "SubmitTaskStateChangeCommand")
-    .sc(schemas_0.SubmitTaskStateChange$)
+    .sc(SubmitTaskStateChange$)
     .build() {
 }
 
-class TagResourceCommand extends client.Command
+class TagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "TagResource", {})
     .n("ECSClient", "TagResourceCommand")
-    .sc(schemas_0.TagResource$)
+    .sc(TagResource$)
     .build() {
 }
 
-class UntagResourceCommand extends client.Command
+class UntagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "UntagResource", {})
     .n("ECSClient", "UntagResourceCommand")
-    .sc(schemas_0.UntagResource$)
+    .sc(UntagResource$)
     .build() {
 }
 
-class UpdateCapacityProviderCommand extends client.Command
+class UpdateCapacityProviderCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "UpdateCapacityProvider", {})
     .n("ECSClient", "UpdateCapacityProviderCommand")
-    .sc(schemas_0.UpdateCapacityProvider$)
+    .sc(UpdateCapacityProvider$)
     .build() {
 }
 
-class UpdateClusterCommand extends client.Command
+class UpdateClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "UpdateCluster", {})
     .n("ECSClient", "UpdateClusterCommand")
-    .sc(schemas_0.UpdateCluster$)
+    .sc(UpdateCluster$)
     .build() {
 }
 
-class UpdateClusterSettingsCommand extends client.Command
+class UpdateClusterSettingsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "UpdateClusterSettings", {})
     .n("ECSClient", "UpdateClusterSettingsCommand")
-    .sc(schemas_0.UpdateClusterSettings$)
+    .sc(UpdateClusterSettings$)
     .build() {
 }
 
-class UpdateContainerAgentCommand extends client.Command
+class UpdateContainerAgentCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "UpdateContainerAgent", {})
     .n("ECSClient", "UpdateContainerAgentCommand")
-    .sc(schemas_0.UpdateContainerAgent$)
+    .sc(UpdateContainerAgent$)
     .build() {
 }
 
-class UpdateContainerInstancesStateCommand extends client.Command
+class UpdateContainerInstancesStateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "UpdateContainerInstancesState", {})
     .n("ECSClient", "UpdateContainerInstancesStateCommand")
-    .sc(schemas_0.UpdateContainerInstancesState$)
+    .sc(UpdateContainerInstancesState$)
     .build() {
 }
 
-class UpdateDaemonCommand extends client.Command
+class UpdateDaemonCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "UpdateDaemon", {})
     .n("ECSClient", "UpdateDaemonCommand")
-    .sc(schemas_0.UpdateDaemon$)
+    .sc(UpdateDaemon$)
     .build() {
 }
 
-class UpdateExpressGatewayServiceCommand extends client.Command
+class UpdateExpressGatewayServiceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "UpdateExpressGatewayService", {})
     .n("ECSClient", "UpdateExpressGatewayServiceCommand")
-    .sc(schemas_0.UpdateExpressGatewayService$)
+    .sc(UpdateExpressGatewayService$)
     .build() {
 }
 
-class UpdateServiceCommand extends client.Command
+class UpdateServiceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "UpdateService", {})
     .n("ECSClient", "UpdateServiceCommand")
-    .sc(schemas_0.UpdateService$)
+    .sc(UpdateService$)
     .build() {
 }
 
-class UpdateServicePrimaryTaskSetCommand extends client.Command
+class UpdateServicePrimaryTaskSetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "UpdateServicePrimaryTaskSet", {})
     .n("ECSClient", "UpdateServicePrimaryTaskSetCommand")
-    .sc(schemas_0.UpdateServicePrimaryTaskSet$)
+    .sc(UpdateServicePrimaryTaskSet$)
     .build() {
 }
 
-class UpdateTaskProtectionCommand extends client.Command
+class UpdateTaskProtectionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "UpdateTaskProtection", {})
     .n("ECSClient", "UpdateTaskProtectionCommand")
-    .sc(schemas_0.UpdateTaskProtection$)
+    .sc(UpdateTaskProtection$)
     .build() {
 }
 
-class UpdateTaskSetCommand extends client.Command
+class UpdateTaskSetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonEC2ContainerServiceV20141113", "UpdateTaskSet", {})
     .n("ECSClient", "UpdateTaskSetCommand")
-    .sc(schemas_0.UpdateTaskSet$)
+    .sc(UpdateTaskSet$)
     .build() {
 }
 
-const paginateListAccountSettings = core.createPaginator(ECSClient, ListAccountSettingsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListAccountSettings = createPaginator(ECSClient, ListAccountSettingsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListAttributes = core.createPaginator(ECSClient, ListAttributesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListAttributes = createPaginator(ECSClient, ListAttributesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListClusters = core.createPaginator(ECSClient, ListClustersCommand, "nextToken", "nextToken", "maxResults");
+const paginateListClusters = createPaginator(ECSClient, ListClustersCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListContainerInstances = core.createPaginator(ECSClient, ListContainerInstancesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListContainerInstances = createPaginator(ECSClient, ListContainerInstancesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListServicesByNamespace = core.createPaginator(ECSClient, ListServicesByNamespaceCommand, "nextToken", "nextToken", "maxResults");
+const paginateListServicesByNamespace = createPaginator(ECSClient, ListServicesByNamespaceCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListServices = core.createPaginator(ECSClient, ListServicesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListServices = createPaginator(ECSClient, ListServicesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListTaskDefinitionFamilies = core.createPaginator(ECSClient, ListTaskDefinitionFamiliesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListTaskDefinitionFamilies = createPaginator(ECSClient, ListTaskDefinitionFamiliesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListTaskDefinitions = core.createPaginator(ECSClient, ListTaskDefinitionsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListTaskDefinitions = createPaginator(ECSClient, ListTaskDefinitionsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListTasks = core.createPaginator(ECSClient, ListTasksCommand, "nextToken", "nextToken", "maxResults");
+const paginateListTasks = createPaginator(ECSClient, ListTasksCommand, "nextToken", "nextToken", "maxResults");
 
-const checkState$8 = async (client$1, input) => {
+const checkState$8 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeDaemonCommand(input));
+        let result = await client.send(new DescribeDaemonCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.daemon.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1069,7 +1072,7 @@ const checkState$8 = async (client$1, input) => {
                 return result.daemon.status;
             };
             if (returnComparator() === "DELETE_IN_PROGRESS") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1077,22 +1080,22 @@ const checkState$8 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForDaemonActive = async (params, input) => {
     const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
 };
 const waitUntilDaemonActive = async (params, input) => {
     const serviceDefaults = { minDelay: 15, 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 DescribeDaemonDeploymentsCommand(input));
+        let result = await client.send(new DescribeDaemonDeploymentsCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -1107,7 +1110,7 @@ const checkState$7 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "STOPPED");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1121,7 +1124,7 @@ const checkState$7 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "MISSING") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1130,22 +1133,22 @@ const checkState$7 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForDaemonDeploymentStopped = async (params, input) => {
     const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
 };
 const waitUntilDaemonDeploymentStopped = async (params, input) => {
     const serviceDefaults = { minDelay: 15, 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 DescribeDaemonDeploymentsCommand(input));
+        let result = await client.send(new DescribeDaemonDeploymentsCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -1160,7 +1163,7 @@ const checkState$6 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "SUCCESSFUL");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1174,7 +1177,7 @@ const checkState$6 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "STOPPED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1189,7 +1192,7 @@ const checkState$6 = 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 };
                 }
             }
         }
@@ -1204,7 +1207,7 @@ const checkState$6 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "ROLLBACK_SUCCESSFUL") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1219,7 +1222,7 @@ const checkState$6 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "MISSING") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1228,29 +1231,29 @@ const checkState$6 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForDaemonDeploymentSuccessful = async (params, input) => {
     const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
 };
 const waitUntilDaemonDeploymentSuccessful = async (params, input) => {
     const serviceDefaults = { minDelay: 15, 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 DescribeDaemonTaskDefinitionCommand(input));
+        let result = await client.send(new DescribeDaemonTaskDefinitionCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.daemonTaskDefinition.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1259,7 +1262,7 @@ const checkState$5 = async (client$1, input) => {
                 return result.daemonTaskDefinition.status;
             };
             if (returnComparator() === "DELETE_IN_PROGRESS") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1268,7 +1271,7 @@ const checkState$5 = async (client$1, input) => {
                 return result.daemonTaskDefinition.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1276,29 +1279,29 @@ const checkState$5 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForDaemonTaskDefinitionActive = async (params, input) => {
     const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
 };
 const waitUntilDaemonTaskDefinitionActive = async (params, input) => {
     const serviceDefaults = { minDelay: 15, 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 DescribeDaemonTaskDefinitionCommand(input));
+        let result = await client.send(new DescribeDaemonTaskDefinitionCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.daemonTaskDefinition.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1306,22 +1309,22 @@ const checkState$4 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForDaemonTaskDefinitionDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 15, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
 };
 const waitUntilDaemonTaskDefinitionDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 15, 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 DescribeServicesCommand(input));
+        let result = await client.send(new DescribeServicesCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -1333,7 +1336,7 @@ const checkState$3 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "MISSING") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1348,7 +1351,7 @@ const checkState$3 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "INACTIVE") {
-                    return { state: client.WaiterState.SUCCESS, reason };
+                    return { state: WaiterState.SUCCESS, reason };
                 }
             }
         }
@@ -1357,22 +1360,22 @@ const checkState$3 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForServicesInactive = async (params, input) => {
     const serviceDefaults = { minDelay: 15, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
 };
 const waitUntilServicesInactive = async (params, input) => {
     const serviceDefaults = { minDelay: 15, maxDelay: 600 };
-    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 DescribeServicesCommand(input));
+        let result = await client.send(new DescribeServicesCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -1384,7 +1387,7 @@ const checkState$2 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "MISSING") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1399,7 +1402,7 @@ const checkState$2 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "DRAINING") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1414,7 +1417,7 @@ const checkState$2 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "INACTIVE") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1427,7 +1430,7 @@ const checkState$2 = async (client$1, input) => {
                 return (filterRes_2.length == 0);
             };
             if (returnComparator() == true) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1435,22 +1438,22 @@ const checkState$2 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForServicesStable = async (params, input) => {
     const serviceDefaults = { minDelay: 15, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
 };
 const waitUntilServicesStable = async (params, input) => {
     const serviceDefaults = { minDelay: 15, maxDelay: 600 };
-    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 DescribeTasksCommand(input));
+        let result = await client.send(new DescribeTasksCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -1462,7 +1465,7 @@ const checkState$1 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "STOPPED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1477,7 +1480,7 @@ const checkState$1 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "MISSING") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -1495,7 +1498,7 @@ const checkState$1 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "RUNNING");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1503,22 +1506,22 @@ const checkState$1 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForTasksRunning = async (params, input) => {
     const serviceDefaults = { minDelay: 6, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
 };
 const waitUntilTasksRunning = async (params, input) => {
     const serviceDefaults = { minDelay: 6, maxDelay: 600 };
-    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 DescribeTasksCommand(input));
+        let result = await client.send(new DescribeTasksCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -1533,7 +1536,7 @@ const checkState = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "STOPPED");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1541,16 +1544,16 @@ const checkState = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForTasksStopped = async (params, input) => {
     const serviceDefaults = { minDelay: 6, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
 const waitUntilTasksStopped = async (params, input) => {
     const serviceDefaults = { minDelay: 6, maxDelay: 600 };
-    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 = {
@@ -1656,7 +1659,7 @@ const waiters = {
 };
 class ECS extends ECSClient {
 }
-client.createAggregatedClient(commands, ECS, { paginators, waiters });
+createAggregatedClient(commands, ECS, { paginators, waiters });
 
 const AcceleratorManufacturer = {
     AMAZON_WEB_SERVICES: "amazon-web-services",
@@ -2214,9 +2217,6 @@ const TaskSetField = {
     TAGS: "TAGS",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.ECSServiceException = ECSServiceException.ECSServiceException;
 exports.AcceleratorManufacturer = AcceleratorManufacturer;
 exports.AcceleratorName = AcceleratorName;
 exports.AcceleratorType = AcceleratorType;
@@ -2428,23 +2428,3 @@ exports.waitUntilServicesInactive = waitUntilServicesInactive;
 exports.waitUntilServicesStable = waitUntilServicesStable;
 exports.waitUntilTasksRunning = waitUntilTasksRunning;
 exports.waitUntilTasksStopped = waitUntilTasksStopped;
-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];
-});