@aws-sdk/client-cloudformation 3.34.0 → 3.37.0

package/dist-es/commands/ListTypeVersionsCommand.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 { ListTypeVersionsInput, ListTypeVersionsOutput } from "../models/models_0";
+import { deserializeAws_queryListTypeVersionsCommand, serializeAws_queryListTypeVersionsCommand, } from "../protocols/Aws_query";
+var ListTypeVersionsCommand = (function (_super) {
+    __extends(ListTypeVersionsCommand, _super);
+    function ListTypeVersionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListTypeVersionsCommand.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 = "ListTypeVersionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListTypeVersionsInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListTypeVersionsOutput.filterSensitiveLog,
+        };
+        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);
+    };
+    ListTypeVersionsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryListTypeVersionsCommand(output, context);
+    };
+    return ListTypeVersionsCommand;
+}($Command));
+export { ListTypeVersionsCommand };

package/dist-es/commands/ListTypesCommand.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 { ListTypesInput, ListTypesOutput } from "../models/models_0";
+import { deserializeAws_queryListTypesCommand, serializeAws_queryListTypesCommand } from "../protocols/Aws_query";
+var ListTypesCommand = (function (_super) {
+    __extends(ListTypesCommand, _super);
+    function ListTypesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListTypesCommand.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 = "ListTypesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListTypesInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListTypesOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListTypesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryListTypesCommand(input, context);
+    };
+    ListTypesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryListTypesCommand(output, context);
+    };
+    return ListTypesCommand;
+}($Command));
+export { ListTypesCommand };

package/dist-es/commands/PublishTypeCommand.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 { PublishTypeInput, PublishTypeOutput } from "../models/models_0";
+import { deserializeAws_queryPublishTypeCommand, serializeAws_queryPublishTypeCommand } from "../protocols/Aws_query";
+var PublishTypeCommand = (function (_super) {
+    __extends(PublishTypeCommand, _super);
+    function PublishTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PublishTypeCommand.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 = "PublishTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PublishTypeInput.filterSensitiveLog,
+            outputFilterSensitiveLog: PublishTypeOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PublishTypeCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryPublishTypeCommand(input, context);
+    };
+    PublishTypeCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryPublishTypeCommand(output, context);
+    };
+    return PublishTypeCommand;
+}($Command));
+export { PublishTypeCommand };

package/dist-es/commands/RecordHandlerProgressCommand.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 { RecordHandlerProgressInput, RecordHandlerProgressOutput } from "../models/models_0";
+import { deserializeAws_queryRecordHandlerProgressCommand, serializeAws_queryRecordHandlerProgressCommand, } from "../protocols/Aws_query";
+var RecordHandlerProgressCommand = (function (_super) {
+    __extends(RecordHandlerProgressCommand, _super);
+    function RecordHandlerProgressCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RecordHandlerProgressCommand.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 = "RecordHandlerProgressCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RecordHandlerProgressInput.filterSensitiveLog,
+            outputFilterSensitiveLog: RecordHandlerProgressOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    RecordHandlerProgressCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryRecordHandlerProgressCommand(input, context);
+    };
+    RecordHandlerProgressCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryRecordHandlerProgressCommand(output, context);
+    };
+    return RecordHandlerProgressCommand;
+}($Command));
+export { RecordHandlerProgressCommand };

package/dist-es/commands/RegisterPublisherCommand.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 { RegisterPublisherInput, RegisterPublisherOutput } from "../models/models_0";
+import { deserializeAws_queryRegisterPublisherCommand, serializeAws_queryRegisterPublisherCommand, } from "../protocols/Aws_query";
+var RegisterPublisherCommand = (function (_super) {
+    __extends(RegisterPublisherCommand, _super);
+    function RegisterPublisherCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RegisterPublisherCommand.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 = "RegisterPublisherCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RegisterPublisherInput.filterSensitiveLog,
+            outputFilterSensitiveLog: RegisterPublisherOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    RegisterPublisherCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryRegisterPublisherCommand(input, context);
+    };
+    RegisterPublisherCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryRegisterPublisherCommand(output, context);
+    };
+    return RegisterPublisherCommand;
+}($Command));
+export { RegisterPublisherCommand };

package/dist-es/commands/RegisterTypeCommand.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 { RegisterTypeInput, RegisterTypeOutput } from "../models/models_0";
+import { deserializeAws_queryRegisterTypeCommand, serializeAws_queryRegisterTypeCommand } from "../protocols/Aws_query";
+var RegisterTypeCommand = (function (_super) {
+    __extends(RegisterTypeCommand, _super);
+    function RegisterTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RegisterTypeCommand.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 = "RegisterTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RegisterTypeInput.filterSensitiveLog,
+            outputFilterSensitiveLog: RegisterTypeOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    RegisterTypeCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryRegisterTypeCommand(input, context);
+    };
+    RegisterTypeCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryRegisterTypeCommand(output, context);
+    };
+    return RegisterTypeCommand;
+}($Command));
+export { RegisterTypeCommand };

package/dist-es/commands/RollbackStackCommand.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 { RollbackStackInput, RollbackStackOutput } from "../models/models_0";
+import { deserializeAws_queryRollbackStackCommand, serializeAws_queryRollbackStackCommand, } from "../protocols/Aws_query";
+var RollbackStackCommand = (function (_super) {
+    __extends(RollbackStackCommand, _super);
+    function RollbackStackCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RollbackStackCommand.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 = "RollbackStackCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RollbackStackInput.filterSensitiveLog,
+            outputFilterSensitiveLog: RollbackStackOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    RollbackStackCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryRollbackStackCommand(input, context);
+    };
+    RollbackStackCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryRollbackStackCommand(output, context);
+    };
+    return RollbackStackCommand;
+}($Command));
+export { RollbackStackCommand };

package/dist-es/commands/SetStackPolicyCommand.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 { SetStackPolicyInput } from "../models/models_0";
+import { deserializeAws_querySetStackPolicyCommand, serializeAws_querySetStackPolicyCommand, } from "../protocols/Aws_query";
+var SetStackPolicyCommand = (function (_super) {
+    __extends(SetStackPolicyCommand, _super);
+    function SetStackPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SetStackPolicyCommand.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 = "SetStackPolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SetStackPolicyInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SetStackPolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySetStackPolicyCommand(input, context);
+    };
+    SetStackPolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySetStackPolicyCommand(output, context);
+    };
+    return SetStackPolicyCommand;
+}($Command));
+export { SetStackPolicyCommand };

package/dist-es/commands/SetTypeConfigurationCommand.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 { SetTypeConfigurationInput, SetTypeConfigurationOutput } from "../models/models_0";
+import { deserializeAws_querySetTypeConfigurationCommand, serializeAws_querySetTypeConfigurationCommand, } from "../protocols/Aws_query";
+var SetTypeConfigurationCommand = (function (_super) {
+    __extends(SetTypeConfigurationCommand, _super);
+    function SetTypeConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SetTypeConfigurationCommand.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 = "SetTypeConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SetTypeConfigurationInput.filterSensitiveLog,
+            outputFilterSensitiveLog: SetTypeConfigurationOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SetTypeConfigurationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySetTypeConfigurationCommand(input, context);
+    };
+    SetTypeConfigurationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySetTypeConfigurationCommand(output, context);
+    };
+    return SetTypeConfigurationCommand;
+}($Command));
+export { SetTypeConfigurationCommand };

package/dist-es/commands/SetTypeDefaultVersionCommand.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 { SetTypeDefaultVersionInput, SetTypeDefaultVersionOutput } from "../models/models_0";
+import { deserializeAws_querySetTypeDefaultVersionCommand, serializeAws_querySetTypeDefaultVersionCommand, } from "../protocols/Aws_query";
+var SetTypeDefaultVersionCommand = (function (_super) {
+    __extends(SetTypeDefaultVersionCommand, _super);
+    function SetTypeDefaultVersionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SetTypeDefaultVersionCommand.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 = "SetTypeDefaultVersionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SetTypeDefaultVersionInput.filterSensitiveLog,
+            outputFilterSensitiveLog: SetTypeDefaultVersionOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SetTypeDefaultVersionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySetTypeDefaultVersionCommand(input, context);
+    };
+    SetTypeDefaultVersionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySetTypeDefaultVersionCommand(output, context);
+    };
+    return SetTypeDefaultVersionCommand;
+}($Command));
+export { SetTypeDefaultVersionCommand };

package/dist-es/commands/SignalResourceCommand.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 { SignalResourceInput } from "../models/models_0";
+import { deserializeAws_querySignalResourceCommand, serializeAws_querySignalResourceCommand, } from "../protocols/Aws_query";
+var SignalResourceCommand = (function (_super) {
+    __extends(SignalResourceCommand, _super);
+    function SignalResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SignalResourceCommand.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 = "SignalResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SignalResourceInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SignalResourceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySignalResourceCommand(input, context);
+    };
+    SignalResourceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySignalResourceCommand(output, context);
+    };
+    return SignalResourceCommand;
+}($Command));
+export { SignalResourceCommand };

package/dist-es/commands/StopStackSetOperationCommand.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 { StopStackSetOperationInput, StopStackSetOperationOutput } from "../models/models_0";
+import { deserializeAws_queryStopStackSetOperationCommand, serializeAws_queryStopStackSetOperationCommand, } from "../protocols/Aws_query";
+var StopStackSetOperationCommand = (function (_super) {
+    __extends(StopStackSetOperationCommand, _super);
+    function StopStackSetOperationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StopStackSetOperationCommand.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 = "StopStackSetOperationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StopStackSetOperationInput.filterSensitiveLog,
+            outputFilterSensitiveLog: StopStackSetOperationOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StopStackSetOperationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryStopStackSetOperationCommand(input, context);
+    };
+    StopStackSetOperationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryStopStackSetOperationCommand(output, context);
+    };
+    return StopStackSetOperationCommand;
+}($Command));
+export { StopStackSetOperationCommand };

package/dist-es/commands/TestTypeCommand.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 { TestTypeInput, TestTypeOutput } from "../models/models_0";
+import { deserializeAws_queryTestTypeCommand, serializeAws_queryTestTypeCommand } from "../protocols/Aws_query";
+var TestTypeCommand = (function (_super) {
+    __extends(TestTypeCommand, _super);
+    function TestTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    TestTypeCommand.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 = "TestTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: TestTypeInput.filterSensitiveLog,
+            outputFilterSensitiveLog: TestTypeOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    TestTypeCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryTestTypeCommand(input, context);
+    };
+    TestTypeCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryTestTypeCommand(output, context);
+    };
+    return TestTypeCommand;
+}($Command));
+export { TestTypeCommand };

package/dist-es/commands/UpdateStackCommand.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 { UpdateStackInput, UpdateStackOutput } from "../models/models_0";
+import { deserializeAws_queryUpdateStackCommand, serializeAws_queryUpdateStackCommand } from "../protocols/Aws_query";
+var UpdateStackCommand = (function (_super) {
+    __extends(UpdateStackCommand, _super);
+    function UpdateStackCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateStackCommand.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 = "UpdateStackCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateStackInput.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateStackOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateStackCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryUpdateStackCommand(input, context);
+    };
+    UpdateStackCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryUpdateStackCommand(output, context);
+    };
+    return UpdateStackCommand;
+}($Command));
+export { UpdateStackCommand };

package/dist-es/commands/UpdateStackInstancesCommand.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 { UpdateStackInstancesInput, UpdateStackInstancesOutput } from "../models/models_0";
+import { deserializeAws_queryUpdateStackInstancesCommand, serializeAws_queryUpdateStackInstancesCommand, } from "../protocols/Aws_query";
+var UpdateStackInstancesCommand = (function (_super) {
+    __extends(UpdateStackInstancesCommand, _super);
+    function UpdateStackInstancesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateStackInstancesCommand.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 = "UpdateStackInstancesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateStackInstancesInput.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateStackInstancesOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateStackInstancesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryUpdateStackInstancesCommand(input, context);
+    };
+    UpdateStackInstancesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryUpdateStackInstancesCommand(output, context);
+    };
+    return UpdateStackInstancesCommand;
+}($Command));
+export { UpdateStackInstancesCommand };

package/dist-es/commands/UpdateStackSetCommand.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 { UpdateStackSetInput, UpdateStackSetOutput } from "../models/models_0";
+import { deserializeAws_queryUpdateStackSetCommand, serializeAws_queryUpdateStackSetCommand, } from "../protocols/Aws_query";
+var UpdateStackSetCommand = (function (_super) {
+    __extends(UpdateStackSetCommand, _super);
+    function UpdateStackSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateStackSetCommand.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 = "UpdateStackSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateStackSetInput.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateStackSetOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateStackSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryUpdateStackSetCommand(input, context);
+    };
+    UpdateStackSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryUpdateStackSetCommand(output, context);
+    };
+    return UpdateStackSetCommand;
+}($Command));
+export { UpdateStackSetCommand };