@aws-sdk/client-ecs 3.184.0 → 3.186.0

package/dist-es/commands/DeleteTaskSetCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteTaskSetRequestFilterSensitiveLog, DeleteTaskSetResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeleteTaskSetCommand, serializeAws_json1_1DeleteTaskSetCommand, } from "../protocols/Aws_json1_1";
-export class DeleteTaskSetCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteTaskSetCommand = (function (_super) {
+    __extends(DeleteTaskSetCommand, _super);
+    function DeleteTaskSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteTaskSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ECSClient";
-        const commandName = "DeleteTaskSetCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ECSClient";
+        var commandName = "DeleteTaskSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteTaskSetRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteTaskSetResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteTaskSetCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeleteTaskSetCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteTaskSetCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteTaskSetCommand(output, context);
-    }
-}
+    };
+    return DeleteTaskSetCommand;
+}($Command));
+export { DeleteTaskSetCommand };

package/dist-es/commands/DeregisterContainerInstanceCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeregisterContainerInstanceRequestFilterSensitiveLog, DeregisterContainerInstanceResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeregisterContainerInstanceCommand, serializeAws_json1_1DeregisterContainerInstanceCommand, } from "../protocols/Aws_json1_1";
-export class DeregisterContainerInstanceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeregisterContainerInstanceCommand = (function (_super) {
+    __extends(DeregisterContainerInstanceCommand, _super);
+    function DeregisterContainerInstanceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeregisterContainerInstanceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ECSClient";
-        const commandName = "DeregisterContainerInstanceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ECSClient";
+        var commandName = "DeregisterContainerInstanceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeregisterContainerInstanceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeregisterContainerInstanceResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeregisterContainerInstanceCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeregisterContainerInstanceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeregisterContainerInstanceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeregisterContainerInstanceCommand(output, context);
-    }
-}
+    };
+    return DeregisterContainerInstanceCommand;
+}($Command));
+export { DeregisterContainerInstanceCommand };

package/dist-es/commands/DeregisterTaskDefinitionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeregisterTaskDefinitionRequestFilterSensitiveLog, DeregisterTaskDefinitionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeregisterTaskDefinitionCommand, serializeAws_json1_1DeregisterTaskDefinitionCommand, } from "../protocols/Aws_json1_1";
-export class DeregisterTaskDefinitionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeregisterTaskDefinitionCommand = (function (_super) {
+    __extends(DeregisterTaskDefinitionCommand, _super);
+    function DeregisterTaskDefinitionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeregisterTaskDefinitionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ECSClient";
-        const commandName = "DeregisterTaskDefinitionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ECSClient";
+        var commandName = "DeregisterTaskDefinitionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeregisterTaskDefinitionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeregisterTaskDefinitionResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeregisterTaskDefinitionCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeregisterTaskDefinitionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeregisterTaskDefinitionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeregisterTaskDefinitionCommand(output, context);
-    }
-}
+    };
+    return DeregisterTaskDefinitionCommand;
+}($Command));
+export { DeregisterTaskDefinitionCommand };

package/dist-es/commands/DescribeCapacityProvidersCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeCapacityProvidersRequestFilterSensitiveLog, DescribeCapacityProvidersResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DescribeCapacityProvidersCommand, serializeAws_json1_1DescribeCapacityProvidersCommand, } from "../protocols/Aws_json1_1";
-export class DescribeCapacityProvidersCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeCapacityProvidersCommand = (function (_super) {
+    __extends(DescribeCapacityProvidersCommand, _super);
+    function DescribeCapacityProvidersCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeCapacityProvidersCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ECSClient";
-        const commandName = "DescribeCapacityProvidersCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ECSClient";
+        var commandName = "DescribeCapacityProvidersCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeCapacityProvidersRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeCapacityProvidersResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeCapacityProvidersCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DescribeCapacityProvidersCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeCapacityProvidersCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DescribeCapacityProvidersCommand(output, context);
-    }
-}
+    };
+    return DescribeCapacityProvidersCommand;
+}($Command));
+export { DescribeCapacityProvidersCommand };

package/dist-es/commands/DescribeClustersCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeClustersRequestFilterSensitiveLog, DescribeClustersResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DescribeClustersCommand, serializeAws_json1_1DescribeClustersCommand, } from "../protocols/Aws_json1_1";
-export class DescribeClustersCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeClustersCommand = (function (_super) {
+    __extends(DescribeClustersCommand, _super);
+    function DescribeClustersCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeClustersCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ECSClient";
-        const commandName = "DescribeClustersCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ECSClient";
+        var commandName = "DescribeClustersCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeClustersRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeClustersResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeClustersCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DescribeClustersCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeClustersCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DescribeClustersCommand(output, context);
-    }
-}
+    };
+    return DescribeClustersCommand;
+}($Command));
+export { DescribeClustersCommand };

package/dist-es/commands/DescribeContainerInstancesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeContainerInstancesRequestFilterSensitiveLog, DescribeContainerInstancesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DescribeContainerInstancesCommand, serializeAws_json1_1DescribeContainerInstancesCommand, } from "../protocols/Aws_json1_1";
-export class DescribeContainerInstancesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeContainerInstancesCommand = (function (_super) {
+    __extends(DescribeContainerInstancesCommand, _super);
+    function DescribeContainerInstancesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeContainerInstancesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ECSClient";
-        const commandName = "DescribeContainerInstancesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ECSClient";
+        var commandName = "DescribeContainerInstancesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeContainerInstancesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeContainerInstancesResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeContainerInstancesCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DescribeContainerInstancesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeContainerInstancesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DescribeContainerInstancesCommand(output, context);
-    }
-}
+    };
+    return DescribeContainerInstancesCommand;
+}($Command));
+export { DescribeContainerInstancesCommand };

package/dist-es/commands/DescribeServicesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeServicesRequestFilterSensitiveLog, DescribeServicesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DescribeServicesCommand, serializeAws_json1_1DescribeServicesCommand, } from "../protocols/Aws_json1_1";
-export class DescribeServicesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeServicesCommand = (function (_super) {
+    __extends(DescribeServicesCommand, _super);
+    function DescribeServicesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeServicesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ECSClient";
-        const commandName = "DescribeServicesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ECSClient";
+        var commandName = "DescribeServicesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeServicesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeServicesResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeServicesCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DescribeServicesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeServicesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DescribeServicesCommand(output, context);
-    }
-}
+    };
+    return DescribeServicesCommand;
+}($Command));
+export { DescribeServicesCommand };

package/dist-es/commands/DescribeTaskDefinitionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeTaskDefinitionRequestFilterSensitiveLog, DescribeTaskDefinitionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DescribeTaskDefinitionCommand, serializeAws_json1_1DescribeTaskDefinitionCommand, } from "../protocols/Aws_json1_1";
-export class DescribeTaskDefinitionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeTaskDefinitionCommand = (function (_super) {
+    __extends(DescribeTaskDefinitionCommand, _super);
+    function DescribeTaskDefinitionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeTaskDefinitionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ECSClient";
-        const commandName = "DescribeTaskDefinitionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ECSClient";
+        var commandName = "DescribeTaskDefinitionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeTaskDefinitionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeTaskDefinitionResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeTaskDefinitionCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DescribeTaskDefinitionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeTaskDefinitionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DescribeTaskDefinitionCommand(output, context);
-    }
-}
+    };
+    return DescribeTaskDefinitionCommand;
+}($Command));
+export { DescribeTaskDefinitionCommand };

package/dist-es/commands/DescribeTaskSetsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeTaskSetsRequestFilterSensitiveLog, DescribeTaskSetsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DescribeTaskSetsCommand, serializeAws_json1_1DescribeTaskSetsCommand, } from "../protocols/Aws_json1_1";
-export class DescribeTaskSetsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeTaskSetsCommand = (function (_super) {
+    __extends(DescribeTaskSetsCommand, _super);
+    function DescribeTaskSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeTaskSetsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ECSClient";
-        const commandName = "DescribeTaskSetsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ECSClient";
+        var commandName = "DescribeTaskSetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeTaskSetsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeTaskSetsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeTaskSetsCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DescribeTaskSetsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeTaskSetsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DescribeTaskSetsCommand(output, context);
-    }
-}
+    };
+    return DescribeTaskSetsCommand;
+}($Command));
+export { DescribeTaskSetsCommand };

package/dist-es/commands/DescribeTasksCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeTasksRequestFilterSensitiveLog, DescribeTasksResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DescribeTasksCommand, serializeAws_json1_1DescribeTasksCommand, } from "../protocols/Aws_json1_1";
-export class DescribeTasksCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeTasksCommand = (function (_super) {
+    __extends(DescribeTasksCommand, _super);
+    function DescribeTasksCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeTasksCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ECSClient";
-        const commandName = "DescribeTasksCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ECSClient";
+        var commandName = "DescribeTasksCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeTasksRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeTasksResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeTasksCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DescribeTasksCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeTasksCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DescribeTasksCommand(output, context);
-    }
-}
+    };
+    return DescribeTasksCommand;
+}($Command));
+export { DescribeTasksCommand };