@aws-sdk/client-cloudformation 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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