@aws-sdk/client-cloudformation 3.33.0 → 3.36.1

package/dist-es/commands/EstimateTemplateCostCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { EstimateTemplateCostInput, EstimateTemplateCostOutput } from "../models/models_0";
+import { deserializeAws_queryEstimateTemplateCostCommand, serializeAws_queryEstimateTemplateCostCommand, } from "../protocols/Aws_query";
+var EstimateTemplateCostCommand = (function (_super) {
+    __extends(EstimateTemplateCostCommand, _super);
+    function EstimateTemplateCostCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    EstimateTemplateCostCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "EstimateTemplateCostCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: EstimateTemplateCostInput.filterSensitiveLog,
+            outputFilterSensitiveLog: EstimateTemplateCostOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    EstimateTemplateCostCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryEstimateTemplateCostCommand(input, context);
+    };
+    EstimateTemplateCostCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryEstimateTemplateCostCommand(output, context);
+    };
+    return EstimateTemplateCostCommand;
+}($Command));
+export { EstimateTemplateCostCommand };

package/dist-es/commands/ExecuteChangeSetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ExecuteChangeSetInput, ExecuteChangeSetOutput } from "../models/models_0";
+import { deserializeAws_queryExecuteChangeSetCommand, serializeAws_queryExecuteChangeSetCommand, } from "../protocols/Aws_query";
+var ExecuteChangeSetCommand = (function (_super) {
+    __extends(ExecuteChangeSetCommand, _super);
+    function ExecuteChangeSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ExecuteChangeSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "ExecuteChangeSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ExecuteChangeSetInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ExecuteChangeSetOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ExecuteChangeSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryExecuteChangeSetCommand(input, context);
+    };
+    ExecuteChangeSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryExecuteChangeSetCommand(output, context);
+    };
+    return ExecuteChangeSetCommand;
+}($Command));
+export { ExecuteChangeSetCommand };

package/dist-es/commands/GetStackPolicyCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetStackPolicyInput, GetStackPolicyOutput } from "../models/models_0";
+import { deserializeAws_queryGetStackPolicyCommand, serializeAws_queryGetStackPolicyCommand, } from "../protocols/Aws_query";
+var GetStackPolicyCommand = (function (_super) {
+    __extends(GetStackPolicyCommand, _super);
+    function GetStackPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetStackPolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "GetStackPolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetStackPolicyInput.filterSensitiveLog,
+            outputFilterSensitiveLog: GetStackPolicyOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetStackPolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryGetStackPolicyCommand(input, context);
+    };
+    GetStackPolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryGetStackPolicyCommand(output, context);
+    };
+    return GetStackPolicyCommand;
+}($Command));
+export { GetStackPolicyCommand };

package/dist-es/commands/GetTemplateCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetTemplateInput, GetTemplateOutput } from "../models/models_0";
+import { deserializeAws_queryGetTemplateCommand, serializeAws_queryGetTemplateCommand } from "../protocols/Aws_query";
+var GetTemplateCommand = (function (_super) {
+    __extends(GetTemplateCommand, _super);
+    function GetTemplateCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetTemplateCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "GetTemplateCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetTemplateInput.filterSensitiveLog,
+            outputFilterSensitiveLog: GetTemplateOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetTemplateCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryGetTemplateCommand(input, context);
+    };
+    GetTemplateCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryGetTemplateCommand(output, context);
+    };
+    return GetTemplateCommand;
+}($Command));
+export { GetTemplateCommand };

package/dist-es/commands/GetTemplateSummaryCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetTemplateSummaryInput, GetTemplateSummaryOutput } from "../models/models_0";
+import { deserializeAws_queryGetTemplateSummaryCommand, serializeAws_queryGetTemplateSummaryCommand, } from "../protocols/Aws_query";
+var GetTemplateSummaryCommand = (function (_super) {
+    __extends(GetTemplateSummaryCommand, _super);
+    function GetTemplateSummaryCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetTemplateSummaryCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "GetTemplateSummaryCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetTemplateSummaryInput.filterSensitiveLog,
+            outputFilterSensitiveLog: GetTemplateSummaryOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetTemplateSummaryCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryGetTemplateSummaryCommand(input, context);
+    };
+    GetTemplateSummaryCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryGetTemplateSummaryCommand(output, context);
+    };
+    return GetTemplateSummaryCommand;
+}($Command));
+export { GetTemplateSummaryCommand };

package/dist-es/commands/ImportStacksToStackSetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ImportStacksToStackSetInput, ImportStacksToStackSetOutput } from "../models/models_0";
+import { deserializeAws_queryImportStacksToStackSetCommand, serializeAws_queryImportStacksToStackSetCommand, } from "../protocols/Aws_query";
+var ImportStacksToStackSetCommand = (function (_super) {
+    __extends(ImportStacksToStackSetCommand, _super);
+    function ImportStacksToStackSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ImportStacksToStackSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "ImportStacksToStackSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ImportStacksToStackSetInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ImportStacksToStackSetOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ImportStacksToStackSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryImportStacksToStackSetCommand(input, context);
+    };
+    ImportStacksToStackSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryImportStacksToStackSetCommand(output, context);
+    };
+    return ImportStacksToStackSetCommand;
+}($Command));
+export { ImportStacksToStackSetCommand };

package/dist-es/commands/ListChangeSetsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListChangeSetsInput, ListChangeSetsOutput } from "../models/models_0";
+import { deserializeAws_queryListChangeSetsCommand, serializeAws_queryListChangeSetsCommand, } from "../protocols/Aws_query";
+var ListChangeSetsCommand = (function (_super) {
+    __extends(ListChangeSetsCommand, _super);
+    function ListChangeSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListChangeSetsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFormationClient";
+        var commandName = "ListChangeSetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListChangeSetsInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListChangeSetsOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListChangeSetsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryListChangeSetsCommand(input, context);
+    };
+    ListChangeSetsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryListChangeSetsCommand(output, context);
+    };
+    return ListChangeSetsCommand;
+}($Command));
+export { ListChangeSetsCommand };

package/dist-es/commands/ListExportsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListExportsInput, ListExportsOutput } from "../models/models_0";
+import { deserializeAws_queryListExportsCommand, serializeAws_queryListExportsCommand } from "../protocols/Aws_query";
+var ListExportsCommand = (function (_super) {
+    __extends(ListExportsCommand, _super);
+    function ListExportsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListExportsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: ListExportsInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListExportsOutput.filterSensitiveLog,
+        };
+        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);
+    };
+    ListExportsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryListExportsCommand(output, context);
+    };
+    return ListExportsCommand;
+}($Command));
+export { ListExportsCommand };

package/dist-es/commands/ListImportsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListImportsInput, ListImportsOutput } from "../models/models_0";
+import { deserializeAws_queryListImportsCommand, serializeAws_queryListImportsCommand } from "../protocols/Aws_query";
+var ListImportsCommand = (function (_super) {
+    __extends(ListImportsCommand, _super);
+    function ListImportsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListImportsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: ListImportsInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListImportsOutput.filterSensitiveLog,
+        };
+        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);
+    };
+    ListImportsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryListImportsCommand(output, context);
+    };
+    return ListImportsCommand;
+}($Command));
+export { ListImportsCommand };

package/dist-es/commands/ListStackInstancesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListStackInstancesInput, ListStackInstancesOutput } from "../models/models_0";
+import { deserializeAws_queryListStackInstancesCommand, serializeAws_queryListStackInstancesCommand, } from "../protocols/Aws_query";
+var ListStackInstancesCommand = (function (_super) {
+    __extends(ListStackInstancesCommand, _super);
+    function ListStackInstancesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListStackInstancesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: ListStackInstancesInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListStackInstancesOutput.filterSensitiveLog,
+        };
+        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);
+    };
+    ListStackInstancesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryListStackInstancesCommand(output, context);
+    };
+    return ListStackInstancesCommand;
+}($Command));
+export { ListStackInstancesCommand };

package/dist-es/commands/ListStackResourcesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListStackResourcesInput, ListStackResourcesOutput } from "../models/models_0";
+import { deserializeAws_queryListStackResourcesCommand, serializeAws_queryListStackResourcesCommand, } from "../protocols/Aws_query";
+var ListStackResourcesCommand = (function (_super) {
+    __extends(ListStackResourcesCommand, _super);
+    function ListStackResourcesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListStackResourcesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: ListStackResourcesInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListStackResourcesOutput.filterSensitiveLog,
+        };
+        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);
+    };
+    ListStackResourcesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryListStackResourcesCommand(output, context);
+    };
+    return ListStackResourcesCommand;
+}($Command));
+export { ListStackResourcesCommand };

package/dist-es/commands/ListStackSetOperationResultsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListStackSetOperationResultsInput, ListStackSetOperationResultsOutput } from "../models/models_0";
+import { deserializeAws_queryListStackSetOperationResultsCommand, serializeAws_queryListStackSetOperationResultsCommand, } from "../protocols/Aws_query";
+var ListStackSetOperationResultsCommand = (function (_super) {
+    __extends(ListStackSetOperationResultsCommand, _super);
+    function ListStackSetOperationResultsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListStackSetOperationResultsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: ListStackSetOperationResultsInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListStackSetOperationResultsOutput.filterSensitiveLog,
+        };
+        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);
+    };
+    ListStackSetOperationResultsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryListStackSetOperationResultsCommand(output, context);
+    };
+    return ListStackSetOperationResultsCommand;
+}($Command));
+export { ListStackSetOperationResultsCommand };

package/dist-es/commands/ListStackSetOperationsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListStackSetOperationsInput, ListStackSetOperationsOutput } from "../models/models_0";
+import { deserializeAws_queryListStackSetOperationsCommand, serializeAws_queryListStackSetOperationsCommand, } from "../protocols/Aws_query";
+var ListStackSetOperationsCommand = (function (_super) {
+    __extends(ListStackSetOperationsCommand, _super);
+    function ListStackSetOperationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListStackSetOperationsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: ListStackSetOperationsInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListStackSetOperationsOutput.filterSensitiveLog,
+        };
+        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);
+    };
+    ListStackSetOperationsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryListStackSetOperationsCommand(output, context);
+    };
+    return ListStackSetOperationsCommand;
+}($Command));
+export { ListStackSetOperationsCommand };

package/dist-es/commands/ListStackSetsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListStackSetsInput, ListStackSetsOutput } from "../models/models_0";
+import { deserializeAws_queryListStackSetsCommand, serializeAws_queryListStackSetsCommand, } from "../protocols/Aws_query";
+var ListStackSetsCommand = (function (_super) {
+    __extends(ListStackSetsCommand, _super);
+    function ListStackSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListStackSetsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: ListStackSetsInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListStackSetsOutput.filterSensitiveLog,
+        };
+        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);
+    };
+    ListStackSetsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryListStackSetsCommand(output, context);
+    };
+    return ListStackSetsCommand;
+}($Command));
+export { ListStackSetsCommand };

package/dist-es/commands/ListStacksCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListStacksInput, ListStacksOutput } from "../models/models_0";
+import { deserializeAws_queryListStacksCommand, serializeAws_queryListStacksCommand } from "../protocols/Aws_query";
+var ListStacksCommand = (function (_super) {
+    __extends(ListStacksCommand, _super);
+    function ListStacksCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListStacksCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: ListStacksInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListStacksOutput.filterSensitiveLog,
+        };
+        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);
+    };
+    ListStacksCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryListStacksCommand(output, context);
+    };
+    return ListStacksCommand;
+}($Command));
+export { ListStacksCommand };

package/dist-es/commands/ListTypeRegistrationsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListTypeRegistrationsInput, ListTypeRegistrationsOutput } from "../models/models_0";
+import { deserializeAws_queryListTypeRegistrationsCommand, serializeAws_queryListTypeRegistrationsCommand, } from "../protocols/Aws_query";
+var ListTypeRegistrationsCommand = (function (_super) {
+    __extends(ListTypeRegistrationsCommand, _super);
+    function ListTypeRegistrationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListTypeRegistrationsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: ListTypeRegistrationsInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListTypeRegistrationsOutput.filterSensitiveLog,
+        };
+        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);
+    };
+    ListTypeRegistrationsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryListTypeRegistrationsCommand(output, context);
+    };
+    return ListTypeRegistrationsCommand;
+}($Command));
+export { ListTypeRegistrationsCommand };