@aws-sdk/client-ecs 3.184.0 → 3.186.0

package/dist-es/ECS.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { CreateCapacityProviderCommand, } from "./commands/CreateCapacityProviderCommand";
 import { CreateClusterCommand, } from "./commands/CreateClusterCommand";
 import { CreateServiceCommand, } from "./commands/CreateServiceCommand";
@@ -51,733 +52,739 @@ import { UpdateServiceCommand, } from "./commands/UpdateServiceCommand";
 import { UpdateServicePrimaryTaskSetCommand, } from "./commands/UpdateServicePrimaryTaskSetCommand";
 import { UpdateTaskSetCommand, } from "./commands/UpdateTaskSetCommand";
 import { ECSClient } from "./ECSClient";
-export class ECS extends ECSClient {
-    createCapacityProvider(args, optionsOrCb, cb) {
-        const command = new CreateCapacityProviderCommand(args);
+var ECS = (function (_super) {
+    __extends(ECS, _super);
+    function ECS() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ECS.prototype.createCapacityProvider = function (args, optionsOrCb, cb) {
+        var command = new CreateCapacityProviderCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createCluster(args, optionsOrCb, cb) {
-        const command = new CreateClusterCommand(args);
+    };
+    ECS.prototype.createCluster = function (args, optionsOrCb, cb) {
+        var command = new CreateClusterCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createService(args, optionsOrCb, cb) {
-        const command = new CreateServiceCommand(args);
+    };
+    ECS.prototype.createService = function (args, optionsOrCb, cb) {
+        var command = new CreateServiceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createTaskSet(args, optionsOrCb, cb) {
-        const command = new CreateTaskSetCommand(args);
+    };
+    ECS.prototype.createTaskSet = function (args, optionsOrCb, cb) {
+        var command = new CreateTaskSetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteAccountSetting(args, optionsOrCb, cb) {
-        const command = new DeleteAccountSettingCommand(args);
+    };
+    ECS.prototype.deleteAccountSetting = function (args, optionsOrCb, cb) {
+        var command = new DeleteAccountSettingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteAttributes(args, optionsOrCb, cb) {
-        const command = new DeleteAttributesCommand(args);
+    };
+    ECS.prototype.deleteAttributes = function (args, optionsOrCb, cb) {
+        var command = new DeleteAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteCapacityProvider(args, optionsOrCb, cb) {
-        const command = new DeleteCapacityProviderCommand(args);
+    };
+    ECS.prototype.deleteCapacityProvider = function (args, optionsOrCb, cb) {
+        var command = new DeleteCapacityProviderCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteCluster(args, optionsOrCb, cb) {
-        const command = new DeleteClusterCommand(args);
+    };
+    ECS.prototype.deleteCluster = function (args, optionsOrCb, cb) {
+        var command = new DeleteClusterCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteService(args, optionsOrCb, cb) {
-        const command = new DeleteServiceCommand(args);
+    };
+    ECS.prototype.deleteService = function (args, optionsOrCb, cb) {
+        var command = new DeleteServiceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteTaskSet(args, optionsOrCb, cb) {
-        const command = new DeleteTaskSetCommand(args);
+    };
+    ECS.prototype.deleteTaskSet = function (args, optionsOrCb, cb) {
+        var command = new DeleteTaskSetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deregisterContainerInstance(args, optionsOrCb, cb) {
-        const command = new DeregisterContainerInstanceCommand(args);
+    };
+    ECS.prototype.deregisterContainerInstance = function (args, optionsOrCb, cb) {
+        var command = new DeregisterContainerInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deregisterTaskDefinition(args, optionsOrCb, cb) {
-        const command = new DeregisterTaskDefinitionCommand(args);
+    };
+    ECS.prototype.deregisterTaskDefinition = function (args, optionsOrCb, cb) {
+        var command = new DeregisterTaskDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeCapacityProviders(args, optionsOrCb, cb) {
-        const command = new DescribeCapacityProvidersCommand(args);
+    };
+    ECS.prototype.describeCapacityProviders = function (args, optionsOrCb, cb) {
+        var command = new DescribeCapacityProvidersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeClusters(args, optionsOrCb, cb) {
-        const command = new DescribeClustersCommand(args);
+    };
+    ECS.prototype.describeClusters = function (args, optionsOrCb, cb) {
+        var command = new DescribeClustersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeContainerInstances(args, optionsOrCb, cb) {
-        const command = new DescribeContainerInstancesCommand(args);
+    };
+    ECS.prototype.describeContainerInstances = function (args, optionsOrCb, cb) {
+        var command = new DescribeContainerInstancesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeServices(args, optionsOrCb, cb) {
-        const command = new DescribeServicesCommand(args);
+    };
+    ECS.prototype.describeServices = function (args, optionsOrCb, cb) {
+        var command = new DescribeServicesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeTaskDefinition(args, optionsOrCb, cb) {
-        const command = new DescribeTaskDefinitionCommand(args);
+    };
+    ECS.prototype.describeTaskDefinition = function (args, optionsOrCb, cb) {
+        var command = new DescribeTaskDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeTasks(args, optionsOrCb, cb) {
-        const command = new DescribeTasksCommand(args);
+    };
+    ECS.prototype.describeTasks = function (args, optionsOrCb, cb) {
+        var command = new DescribeTasksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeTaskSets(args, optionsOrCb, cb) {
-        const command = new DescribeTaskSetsCommand(args);
+    };
+    ECS.prototype.describeTaskSets = function (args, optionsOrCb, cb) {
+        var command = new DescribeTaskSetsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    discoverPollEndpoint(args, optionsOrCb, cb) {
-        const command = new DiscoverPollEndpointCommand(args);
+    };
+    ECS.prototype.discoverPollEndpoint = function (args, optionsOrCb, cb) {
+        var command = new DiscoverPollEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    executeCommand(args, optionsOrCb, cb) {
-        const command = new ExecuteCommandCommand(args);
+    };
+    ECS.prototype.executeCommand = function (args, optionsOrCb, cb) {
+        var command = new ExecuteCommandCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listAccountSettings(args, optionsOrCb, cb) {
-        const command = new ListAccountSettingsCommand(args);
+    };
+    ECS.prototype.listAccountSettings = function (args, optionsOrCb, cb) {
+        var command = new ListAccountSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listAttributes(args, optionsOrCb, cb) {
-        const command = new ListAttributesCommand(args);
+    };
+    ECS.prototype.listAttributes = function (args, optionsOrCb, cb) {
+        var command = new ListAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listClusters(args, optionsOrCb, cb) {
-        const command = new ListClustersCommand(args);
+    };
+    ECS.prototype.listClusters = function (args, optionsOrCb, cb) {
+        var command = new ListClustersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listContainerInstances(args, optionsOrCb, cb) {
-        const command = new ListContainerInstancesCommand(args);
+    };
+    ECS.prototype.listContainerInstances = function (args, optionsOrCb, cb) {
+        var command = new ListContainerInstancesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listServices(args, optionsOrCb, cb) {
-        const command = new ListServicesCommand(args);
+    };
+    ECS.prototype.listServices = function (args, optionsOrCb, cb) {
+        var command = new ListServicesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTagsForResource(args, optionsOrCb, cb) {
-        const command = new ListTagsForResourceCommand(args);
+    };
+    ECS.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
+        var command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTaskDefinitionFamilies(args, optionsOrCb, cb) {
-        const command = new ListTaskDefinitionFamiliesCommand(args);
+    };
+    ECS.prototype.listTaskDefinitionFamilies = function (args, optionsOrCb, cb) {
+        var command = new ListTaskDefinitionFamiliesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTaskDefinitions(args, optionsOrCb, cb) {
-        const command = new ListTaskDefinitionsCommand(args);
+    };
+    ECS.prototype.listTaskDefinitions = function (args, optionsOrCb, cb) {
+        var command = new ListTaskDefinitionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTasks(args, optionsOrCb, cb) {
-        const command = new ListTasksCommand(args);
+    };
+    ECS.prototype.listTasks = function (args, optionsOrCb, cb) {
+        var command = new ListTasksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putAccountSetting(args, optionsOrCb, cb) {
-        const command = new PutAccountSettingCommand(args);
+    };
+    ECS.prototype.putAccountSetting = function (args, optionsOrCb, cb) {
+        var command = new PutAccountSettingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putAccountSettingDefault(args, optionsOrCb, cb) {
-        const command = new PutAccountSettingDefaultCommand(args);
+    };
+    ECS.prototype.putAccountSettingDefault = function (args, optionsOrCb, cb) {
+        var command = new PutAccountSettingDefaultCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putAttributes(args, optionsOrCb, cb) {
-        const command = new PutAttributesCommand(args);
+    };
+    ECS.prototype.putAttributes = function (args, optionsOrCb, cb) {
+        var command = new PutAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putClusterCapacityProviders(args, optionsOrCb, cb) {
-        const command = new PutClusterCapacityProvidersCommand(args);
+    };
+    ECS.prototype.putClusterCapacityProviders = function (args, optionsOrCb, cb) {
+        var command = new PutClusterCapacityProvidersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    registerContainerInstance(args, optionsOrCb, cb) {
-        const command = new RegisterContainerInstanceCommand(args);
+    };
+    ECS.prototype.registerContainerInstance = function (args, optionsOrCb, cb) {
+        var command = new RegisterContainerInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    registerTaskDefinition(args, optionsOrCb, cb) {
-        const command = new RegisterTaskDefinitionCommand(args);
+    };
+    ECS.prototype.registerTaskDefinition = function (args, optionsOrCb, cb) {
+        var command = new RegisterTaskDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    runTask(args, optionsOrCb, cb) {
-        const command = new RunTaskCommand(args);
+    };
+    ECS.prototype.runTask = function (args, optionsOrCb, cb) {
+        var command = new RunTaskCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startTask(args, optionsOrCb, cb) {
-        const command = new StartTaskCommand(args);
+    };
+    ECS.prototype.startTask = function (args, optionsOrCb, cb) {
+        var command = new StartTaskCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopTask(args, optionsOrCb, cb) {
-        const command = new StopTaskCommand(args);
+    };
+    ECS.prototype.stopTask = function (args, optionsOrCb, cb) {
+        var command = new StopTaskCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    submitAttachmentStateChanges(args, optionsOrCb, cb) {
-        const command = new SubmitAttachmentStateChangesCommand(args);
+    };
+    ECS.prototype.submitAttachmentStateChanges = function (args, optionsOrCb, cb) {
+        var command = new SubmitAttachmentStateChangesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    submitContainerStateChange(args, optionsOrCb, cb) {
-        const command = new SubmitContainerStateChangeCommand(args);
+    };
+    ECS.prototype.submitContainerStateChange = function (args, optionsOrCb, cb) {
+        var command = new SubmitContainerStateChangeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    submitTaskStateChange(args, optionsOrCb, cb) {
-        const command = new SubmitTaskStateChangeCommand(args);
+    };
+    ECS.prototype.submitTaskStateChange = function (args, optionsOrCb, cb) {
+        var command = new SubmitTaskStateChangeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    tagResource(args, optionsOrCb, cb) {
-        const command = new TagResourceCommand(args);
+    };
+    ECS.prototype.tagResource = function (args, optionsOrCb, cb) {
+        var command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    untagResource(args, optionsOrCb, cb) {
-        const command = new UntagResourceCommand(args);
+    };
+    ECS.prototype.untagResource = function (args, optionsOrCb, cb) {
+        var command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateCapacityProvider(args, optionsOrCb, cb) {
-        const command = new UpdateCapacityProviderCommand(args);
+    };
+    ECS.prototype.updateCapacityProvider = function (args, optionsOrCb, cb) {
+        var command = new UpdateCapacityProviderCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateCluster(args, optionsOrCb, cb) {
-        const command = new UpdateClusterCommand(args);
+    };
+    ECS.prototype.updateCluster = function (args, optionsOrCb, cb) {
+        var command = new UpdateClusterCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateClusterSettings(args, optionsOrCb, cb) {
-        const command = new UpdateClusterSettingsCommand(args);
+    };
+    ECS.prototype.updateClusterSettings = function (args, optionsOrCb, cb) {
+        var command = new UpdateClusterSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateContainerAgent(args, optionsOrCb, cb) {
-        const command = new UpdateContainerAgentCommand(args);
+    };
+    ECS.prototype.updateContainerAgent = function (args, optionsOrCb, cb) {
+        var command = new UpdateContainerAgentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateContainerInstancesState(args, optionsOrCb, cb) {
-        const command = new UpdateContainerInstancesStateCommand(args);
+    };
+    ECS.prototype.updateContainerInstancesState = function (args, optionsOrCb, cb) {
+        var command = new UpdateContainerInstancesStateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateService(args, optionsOrCb, cb) {
-        const command = new UpdateServiceCommand(args);
+    };
+    ECS.prototype.updateService = function (args, optionsOrCb, cb) {
+        var command = new UpdateServiceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateServicePrimaryTaskSet(args, optionsOrCb, cb) {
-        const command = new UpdateServicePrimaryTaskSetCommand(args);
+    };
+    ECS.prototype.updateServicePrimaryTaskSet = function (args, optionsOrCb, cb) {
+        var command = new UpdateServicePrimaryTaskSetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateTaskSet(args, optionsOrCb, cb) {
-        const command = new UpdateTaskSetCommand(args);
+    };
+    ECS.prototype.updateTaskSet = function (args, optionsOrCb, cb) {
+        var command = new UpdateTaskSetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-}
+    };
+    return ECS;
+}(ECSClient));
+export { ECS };