@aws-sdk/client-cloudformation 3.186.0 → 3.190.0

package/dist-es/commands/ListTypesCommand.js

@@ -1,39 +1,32 @@
-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";
-var ListTypesCommand = (function (_super) {
-    __extends(ListTypesCommand, _super);
-    function ListTypesCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ListTypesCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ListTypesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFormationClient";
+        const commandName = "ListTypesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ListTypesInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListTypesOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ListTypesCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryListTypesCommand(input, context);
-    };
-    ListTypesCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryListTypesCommand(output, context);
-    };
-    return ListTypesCommand;
-}($Command));
-export { ListTypesCommand };
+    }
+}

package/dist-es/commands/PublishTypeCommand.js

@@ -1,39 +1,32 @@
-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";
-var PublishTypeCommand = (function (_super) {
-    __extends(PublishTypeCommand, _super);
-    function PublishTypeCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class PublishTypeCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    PublishTypeCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFormationClient";
+        const commandName = "PublishTypeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: PublishTypeInputFilterSensitiveLog,
             outputFilterSensitiveLog: PublishTypeOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    PublishTypeCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryPublishTypeCommand(input, context);
-    };
-    PublishTypeCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryPublishTypeCommand(output, context);
-    };
-    return PublishTypeCommand;
-}($Command));
-export { PublishTypeCommand };
+    }
+}

package/dist-es/commands/RecordHandlerProgressCommand.js

@@ -1,39 +1,32 @@
-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";
-var RecordHandlerProgressCommand = (function (_super) {
-    __extends(RecordHandlerProgressCommand, _super);
-    function RecordHandlerProgressCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class RecordHandlerProgressCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    RecordHandlerProgressCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFormationClient";
+        const commandName = "RecordHandlerProgressCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: RecordHandlerProgressInputFilterSensitiveLog,
             outputFilterSensitiveLog: RecordHandlerProgressOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    RecordHandlerProgressCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryRecordHandlerProgressCommand(input, context);
-    };
-    RecordHandlerProgressCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryRecordHandlerProgressCommand(output, context);
-    };
-    return RecordHandlerProgressCommand;
-}($Command));
-export { RecordHandlerProgressCommand };
+    }
+}

package/dist-es/commands/RegisterPublisherCommand.js

@@ -1,39 +1,32 @@
-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";
-var RegisterPublisherCommand = (function (_super) {
-    __extends(RegisterPublisherCommand, _super);
-    function RegisterPublisherCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class RegisterPublisherCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    RegisterPublisherCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFormationClient";
+        const commandName = "RegisterPublisherCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: RegisterPublisherInputFilterSensitiveLog,
             outputFilterSensitiveLog: RegisterPublisherOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    RegisterPublisherCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryRegisterPublisherCommand(input, context);
-    };
-    RegisterPublisherCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryRegisterPublisherCommand(output, context);
-    };
-    return RegisterPublisherCommand;
-}($Command));
-export { RegisterPublisherCommand };
+    }
+}

package/dist-es/commands/RegisterTypeCommand.js

@@ -1,39 +1,32 @@
-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";
-var RegisterTypeCommand = (function (_super) {
-    __extends(RegisterTypeCommand, _super);
-    function RegisterTypeCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class RegisterTypeCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    RegisterTypeCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFormationClient";
+        const commandName = "RegisterTypeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: RegisterTypeInputFilterSensitiveLog,
             outputFilterSensitiveLog: RegisterTypeOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    RegisterTypeCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryRegisterTypeCommand(input, context);
-    };
-    RegisterTypeCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryRegisterTypeCommand(output, context);
-    };
-    return RegisterTypeCommand;
-}($Command));
-export { RegisterTypeCommand };
+    }
+}

package/dist-es/commands/RollbackStackCommand.js

@@ -1,39 +1,32 @@
-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";
-var RollbackStackCommand = (function (_super) {
-    __extends(RollbackStackCommand, _super);
-    function RollbackStackCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class RollbackStackCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    RollbackStackCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFormationClient";
+        const commandName = "RollbackStackCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: RollbackStackInputFilterSensitiveLog,
             outputFilterSensitiveLog: RollbackStackOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    RollbackStackCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryRollbackStackCommand(input, context);
-    };
-    RollbackStackCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryRollbackStackCommand(output, context);
-    };
-    return RollbackStackCommand;
-}($Command));
-export { RollbackStackCommand };
+    }
+}

package/dist-es/commands/SetStackPolicyCommand.js

@@ -1,39 +1,32 @@
-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";
-var SetStackPolicyCommand = (function (_super) {
-    __extends(SetStackPolicyCommand, _super);
-    function SetStackPolicyCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class SetStackPolicyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    SetStackPolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFormationClient";
+        const commandName = "SetStackPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: SetStackPolicyInputFilterSensitiveLog,
-            outputFilterSensitiveLog: function (output) { return output; },
+            outputFilterSensitiveLog: (output) => output,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SetStackPolicyCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_querySetStackPolicyCommand(input, context);
-    };
-    SetStackPolicyCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_querySetStackPolicyCommand(output, context);
-    };
-    return SetStackPolicyCommand;
-}($Command));
-export { SetStackPolicyCommand };
+    }
+}

package/dist-es/commands/SetTypeConfigurationCommand.js

@@ -1,39 +1,32 @@
-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";
-var SetTypeConfigurationCommand = (function (_super) {
-    __extends(SetTypeConfigurationCommand, _super);
-    function SetTypeConfigurationCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class SetTypeConfigurationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    SetTypeConfigurationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFormationClient";
+        const commandName = "SetTypeConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: SetTypeConfigurationInputFilterSensitiveLog,
             outputFilterSensitiveLog: SetTypeConfigurationOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SetTypeConfigurationCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_querySetTypeConfigurationCommand(input, context);
-    };
-    SetTypeConfigurationCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_querySetTypeConfigurationCommand(output, context);
-    };
-    return SetTypeConfigurationCommand;
-}($Command));
-export { SetTypeConfigurationCommand };
+    }
+}

package/dist-es/commands/SetTypeDefaultVersionCommand.js

@@ -1,39 +1,32 @@
-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";
-var SetTypeDefaultVersionCommand = (function (_super) {
-    __extends(SetTypeDefaultVersionCommand, _super);
-    function SetTypeDefaultVersionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class SetTypeDefaultVersionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    SetTypeDefaultVersionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFormationClient";
+        const commandName = "SetTypeDefaultVersionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: SetTypeDefaultVersionInputFilterSensitiveLog,
             outputFilterSensitiveLog: SetTypeDefaultVersionOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SetTypeDefaultVersionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_querySetTypeDefaultVersionCommand(input, context);
-    };
-    SetTypeDefaultVersionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_querySetTypeDefaultVersionCommand(output, context);
-    };
-    return SetTypeDefaultVersionCommand;
-}($Command));
-export { SetTypeDefaultVersionCommand };
+    }
+}

package/dist-es/commands/SignalResourceCommand.js

@@ -1,39 +1,32 @@
-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";
-var SignalResourceCommand = (function (_super) {
-    __extends(SignalResourceCommand, _super);
-    function SignalResourceCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class SignalResourceCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    SignalResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFormationClient";
+        const commandName = "SignalResourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: SignalResourceInputFilterSensitiveLog,
-            outputFilterSensitiveLog: function (output) { return output; },
+            outputFilterSensitiveLog: (output) => output,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SignalResourceCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_querySignalResourceCommand(input, context);
-    };
-    SignalResourceCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_querySignalResourceCommand(output, context);
-    };
-    return SignalResourceCommand;
-}($Command));
-export { SignalResourceCommand };
+    }
+}