@aws-sdk/client-cloudformation 3.183.0 → 3.186.0

package/dist-es/commands/ListExportsCommand.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 { ListExportsInputFilterSensitiveLog, ListExportsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListExportsCommand, serializeAws_queryListExportsCommand } from "../protocols/Aws_query";
-export class ListExportsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListExportsCommand = (function (_super) {
+    __extends(ListExportsCommand, _super);
+    function ListExportsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListExportsCommand.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 = "CloudFormationClient";
-        const commandName = "ListExportsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "ListExportsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListExportsInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListExportsOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListExportsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListExportsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListExportsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListExportsCommand(output, context);
-    }
-}
+    };
+    return ListExportsCommand;
+}($Command));
+export { ListExportsCommand };

package/dist-es/commands/ListImportsCommand.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 { ListImportsInputFilterSensitiveLog, ListImportsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListImportsCommand, serializeAws_queryListImportsCommand } from "../protocols/Aws_query";
-export class ListImportsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListImportsCommand = (function (_super) {
+    __extends(ListImportsCommand, _super);
+    function ListImportsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListImportsCommand.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 = "CloudFormationClient";
-        const commandName = "ListImportsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "ListImportsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListImportsInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListImportsOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListImportsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListImportsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListImportsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListImportsCommand(output, context);
-    }
-}
+    };
+    return ListImportsCommand;
+}($Command));
+export { ListImportsCommand };

package/dist-es/commands/ListStackInstancesCommand.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 { ListStackInstancesInputFilterSensitiveLog, ListStackInstancesOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListStackInstancesCommand, serializeAws_queryListStackInstancesCommand, } from "../protocols/Aws_query";
-export class ListStackInstancesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListStackInstancesCommand = (function (_super) {
+    __extends(ListStackInstancesCommand, _super);
+    function ListStackInstancesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListStackInstancesCommand.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 = "CloudFormationClient";
-        const commandName = "ListStackInstancesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "ListStackInstancesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListStackInstancesInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListStackInstancesOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListStackInstancesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListStackInstancesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListStackInstancesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListStackInstancesCommand(output, context);
-    }
-}
+    };
+    return ListStackInstancesCommand;
+}($Command));
+export { ListStackInstancesCommand };

package/dist-es/commands/ListStackResourcesCommand.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 { ListStackResourcesInputFilterSensitiveLog, ListStackResourcesOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListStackResourcesCommand, serializeAws_queryListStackResourcesCommand, } from "../protocols/Aws_query";
-export class ListStackResourcesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListStackResourcesCommand = (function (_super) {
+    __extends(ListStackResourcesCommand, _super);
+    function ListStackResourcesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListStackResourcesCommand.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 = "CloudFormationClient";
-        const commandName = "ListStackResourcesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "ListStackResourcesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListStackResourcesInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListStackResourcesOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListStackResourcesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListStackResourcesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListStackResourcesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListStackResourcesCommand(output, context);
-    }
-}
+    };
+    return ListStackResourcesCommand;
+}($Command));
+export { ListStackResourcesCommand };

package/dist-es/commands/ListStackSetOperationResultsCommand.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 { ListStackSetOperationResultsInputFilterSensitiveLog, ListStackSetOperationResultsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListStackSetOperationResultsCommand, serializeAws_queryListStackSetOperationResultsCommand, } from "../protocols/Aws_query";
-export class ListStackSetOperationResultsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListStackSetOperationResultsCommand = (function (_super) {
+    __extends(ListStackSetOperationResultsCommand, _super);
+    function ListStackSetOperationResultsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListStackSetOperationResultsCommand.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 = "CloudFormationClient";
-        const commandName = "ListStackSetOperationResultsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "ListStackSetOperationResultsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListStackSetOperationResultsInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListStackSetOperationResultsOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListStackSetOperationResultsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListStackSetOperationResultsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListStackSetOperationResultsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListStackSetOperationResultsCommand(output, context);
-    }
-}
+    };
+    return ListStackSetOperationResultsCommand;
+}($Command));
+export { ListStackSetOperationResultsCommand };

package/dist-es/commands/ListStackSetOperationsCommand.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 { ListStackSetOperationsInputFilterSensitiveLog, ListStackSetOperationsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListStackSetOperationsCommand, serializeAws_queryListStackSetOperationsCommand, } from "../protocols/Aws_query";
-export class ListStackSetOperationsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListStackSetOperationsCommand = (function (_super) {
+    __extends(ListStackSetOperationsCommand, _super);
+    function ListStackSetOperationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListStackSetOperationsCommand.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 = "CloudFormationClient";
-        const commandName = "ListStackSetOperationsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "ListStackSetOperationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListStackSetOperationsInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListStackSetOperationsOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListStackSetOperationsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListStackSetOperationsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListStackSetOperationsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListStackSetOperationsCommand(output, context);
-    }
-}
+    };
+    return ListStackSetOperationsCommand;
+}($Command));
+export { ListStackSetOperationsCommand };

package/dist-es/commands/ListStackSetsCommand.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 { ListStackSetsInputFilterSensitiveLog, ListStackSetsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListStackSetsCommand, serializeAws_queryListStackSetsCommand, } from "../protocols/Aws_query";
-export class ListStackSetsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListStackSetsCommand = (function (_super) {
+    __extends(ListStackSetsCommand, _super);
+    function ListStackSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListStackSetsCommand.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 = "CloudFormationClient";
-        const commandName = "ListStackSetsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "ListStackSetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListStackSetsInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListStackSetsOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListStackSetsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListStackSetsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListStackSetsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListStackSetsCommand(output, context);
-    }
-}
+    };
+    return ListStackSetsCommand;
+}($Command));
+export { ListStackSetsCommand };

package/dist-es/commands/ListStacksCommand.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 { ListStacksInputFilterSensitiveLog, ListStacksOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListStacksCommand, serializeAws_queryListStacksCommand } from "../protocols/Aws_query";
-export class ListStacksCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListStacksCommand = (function (_super) {
+    __extends(ListStacksCommand, _super);
+    function ListStacksCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListStacksCommand.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 = "CloudFormationClient";
-        const commandName = "ListStacksCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "ListStacksCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListStacksInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListStacksOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListStacksCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListStacksCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListStacksCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListStacksCommand(output, context);
-    }
-}
+    };
+    return ListStacksCommand;
+}($Command));
+export { ListStacksCommand };

package/dist-es/commands/ListTypeRegistrationsCommand.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 { ListTypeRegistrationsInputFilterSensitiveLog, ListTypeRegistrationsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListTypeRegistrationsCommand, serializeAws_queryListTypeRegistrationsCommand, } from "../protocols/Aws_query";
-export class ListTypeRegistrationsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListTypeRegistrationsCommand = (function (_super) {
+    __extends(ListTypeRegistrationsCommand, _super);
+    function ListTypeRegistrationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListTypeRegistrationsCommand.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 = "CloudFormationClient";
-        const commandName = "ListTypeRegistrationsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "ListTypeRegistrationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListTypeRegistrationsInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListTypeRegistrationsOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListTypeRegistrationsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListTypeRegistrationsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListTypeRegistrationsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListTypeRegistrationsCommand(output, context);
-    }
-}
+    };
+    return ListTypeRegistrationsCommand;
+}($Command));
+export { ListTypeRegistrationsCommand };

package/dist-es/commands/ListTypeVersionsCommand.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 { ListTypeVersionsInputFilterSensitiveLog, ListTypeVersionsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListTypeVersionsCommand, serializeAws_queryListTypeVersionsCommand, } from "../protocols/Aws_query";
-export class ListTypeVersionsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListTypeVersionsCommand = (function (_super) {
+    __extends(ListTypeVersionsCommand, _super);
+    function ListTypeVersionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListTypeVersionsCommand.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 = "CloudFormationClient";
-        const commandName = "ListTypeVersionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "ListTypeVersionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListTypeVersionsInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListTypeVersionsOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListTypeVersionsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListTypeVersionsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListTypeVersionsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListTypeVersionsCommand(output, context);
-    }
-}
+    };
+    return ListTypeVersionsCommand;
+}($Command));
+export { ListTypeVersionsCommand };