@aws-sdk/client-ssm-contacts 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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