@aws-sdk/client-connect 3.183.0 → 3.185.0

package/dist-es/commands/StartChatContactCommand.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 { StartChatContactRequestFilterSensitiveLog, StartChatContactResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1StartChatContactCommand, serializeAws_restJson1StartChatContactCommand, } from "../protocols/Aws_restJson1";
-export class StartChatContactCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartChatContactCommand = (function (_super) {
+    __extends(StartChatContactCommand, _super);
+    function StartChatContactCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartChatContactCommand.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 = "ConnectClient";
-        const commandName = "StartChatContactCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "StartChatContactCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartChatContactRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartChatContactResponseFilterSensitiveLog,
         };
-        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);
+    };
+    StartChatContactCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1StartChatContactCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartChatContactCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1StartChatContactCommand(output, context);
-    }
-}
+    };
+    return StartChatContactCommand;
+}($Command));
+export { StartChatContactCommand };

package/dist-es/commands/StartContactRecordingCommand.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 { StartContactRecordingRequestFilterSensitiveLog, StartContactRecordingResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1StartContactRecordingCommand, serializeAws_restJson1StartContactRecordingCommand, } from "../protocols/Aws_restJson1";
-export class StartContactRecordingCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartContactRecordingCommand = (function (_super) {
+    __extends(StartContactRecordingCommand, _super);
+    function StartContactRecordingCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartContactRecordingCommand.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 = "ConnectClient";
-        const commandName = "StartContactRecordingCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "StartContactRecordingCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartContactRecordingRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartContactRecordingResponseFilterSensitiveLog,
         };
-        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);
+    };
+    StartContactRecordingCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1StartContactRecordingCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartContactRecordingCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1StartContactRecordingCommand(output, context);
-    }
-}
+    };
+    return StartContactRecordingCommand;
+}($Command));
+export { StartContactRecordingCommand };

package/dist-es/commands/StartContactStreamingCommand.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 { StartContactStreamingRequestFilterSensitiveLog, StartContactStreamingResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1StartContactStreamingCommand, serializeAws_restJson1StartContactStreamingCommand, } from "../protocols/Aws_restJson1";
-export class StartContactStreamingCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartContactStreamingCommand = (function (_super) {
+    __extends(StartContactStreamingCommand, _super);
+    function StartContactStreamingCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartContactStreamingCommand.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 = "ConnectClient";
-        const commandName = "StartContactStreamingCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "StartContactStreamingCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartContactStreamingRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartContactStreamingResponseFilterSensitiveLog,
         };
-        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);
+    };
+    StartContactStreamingCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1StartContactStreamingCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartContactStreamingCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1StartContactStreamingCommand(output, context);
-    }
-}
+    };
+    return StartContactStreamingCommand;
+}($Command));
+export { StartContactStreamingCommand };

package/dist-es/commands/StartOutboundVoiceContactCommand.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 { StartOutboundVoiceContactRequestFilterSensitiveLog, StartOutboundVoiceContactResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1StartOutboundVoiceContactCommand, serializeAws_restJson1StartOutboundVoiceContactCommand, } from "../protocols/Aws_restJson1";
-export class StartOutboundVoiceContactCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartOutboundVoiceContactCommand = (function (_super) {
+    __extends(StartOutboundVoiceContactCommand, _super);
+    function StartOutboundVoiceContactCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartOutboundVoiceContactCommand.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 = "ConnectClient";
-        const commandName = "StartOutboundVoiceContactCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "StartOutboundVoiceContactCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartOutboundVoiceContactRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartOutboundVoiceContactResponseFilterSensitiveLog,
         };
-        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);
+    };
+    StartOutboundVoiceContactCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1StartOutboundVoiceContactCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartOutboundVoiceContactCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1StartOutboundVoiceContactCommand(output, context);
-    }
-}
+    };
+    return StartOutboundVoiceContactCommand;
+}($Command));
+export { StartOutboundVoiceContactCommand };

package/dist-es/commands/StartTaskContactCommand.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 { StartTaskContactRequestFilterSensitiveLog, StartTaskContactResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1StartTaskContactCommand, serializeAws_restJson1StartTaskContactCommand, } from "../protocols/Aws_restJson1";
-export class StartTaskContactCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartTaskContactCommand = (function (_super) {
+    __extends(StartTaskContactCommand, _super);
+    function StartTaskContactCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartTaskContactCommand.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 = "ConnectClient";
-        const commandName = "StartTaskContactCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "StartTaskContactCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartTaskContactRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartTaskContactResponseFilterSensitiveLog,
         };
-        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);
+    };
+    StartTaskContactCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1StartTaskContactCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartTaskContactCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1StartTaskContactCommand(output, context);
-    }
-}
+    };
+    return StartTaskContactCommand;
+}($Command));
+export { StartTaskContactCommand };

package/dist-es/commands/StopContactCommand.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 { StopContactRequestFilterSensitiveLog, StopContactResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1StopContactCommand, serializeAws_restJson1StopContactCommand, } from "../protocols/Aws_restJson1";
-export class StopContactCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StopContactCommand = (function (_super) {
+    __extends(StopContactCommand, _super);
+    function StopContactCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StopContactCommand.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 = "ConnectClient";
-        const commandName = "StopContactCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "StopContactCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StopContactRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StopContactResponseFilterSensitiveLog,
         };
-        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);
+    };
+    StopContactCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1StopContactCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StopContactCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1StopContactCommand(output, context);
-    }
-}
+    };
+    return StopContactCommand;
+}($Command));
+export { StopContactCommand };

package/dist-es/commands/StopContactRecordingCommand.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 { StopContactRecordingRequestFilterSensitiveLog, StopContactRecordingResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1StopContactRecordingCommand, serializeAws_restJson1StopContactRecordingCommand, } from "../protocols/Aws_restJson1";
-export class StopContactRecordingCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StopContactRecordingCommand = (function (_super) {
+    __extends(StopContactRecordingCommand, _super);
+    function StopContactRecordingCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StopContactRecordingCommand.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 = "ConnectClient";
-        const commandName = "StopContactRecordingCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "StopContactRecordingCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StopContactRecordingRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StopContactRecordingResponseFilterSensitiveLog,
         };
-        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);
+    };
+    StopContactRecordingCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1StopContactRecordingCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StopContactRecordingCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1StopContactRecordingCommand(output, context);
-    }
-}
+    };
+    return StopContactRecordingCommand;
+}($Command));
+export { StopContactRecordingCommand };

package/dist-es/commands/StopContactStreamingCommand.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 { StopContactStreamingRequestFilterSensitiveLog, StopContactStreamingResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1StopContactStreamingCommand, serializeAws_restJson1StopContactStreamingCommand, } from "../protocols/Aws_restJson1";
-export class StopContactStreamingCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StopContactStreamingCommand = (function (_super) {
+    __extends(StopContactStreamingCommand, _super);
+    function StopContactStreamingCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StopContactStreamingCommand.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 = "ConnectClient";
-        const commandName = "StopContactStreamingCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "StopContactStreamingCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StopContactStreamingRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StopContactStreamingResponseFilterSensitiveLog,
         };
-        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);
+    };
+    StopContactStreamingCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1StopContactStreamingCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StopContactStreamingCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1StopContactStreamingCommand(output, context);
-    }
-}
+    };
+    return StopContactStreamingCommand;
+}($Command));
+export { StopContactStreamingCommand };

package/dist-es/commands/SuspendContactRecordingCommand.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 { SuspendContactRecordingRequestFilterSensitiveLog, SuspendContactRecordingResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1SuspendContactRecordingCommand, serializeAws_restJson1SuspendContactRecordingCommand, } from "../protocols/Aws_restJson1";
-export class SuspendContactRecordingCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var SuspendContactRecordingCommand = (function (_super) {
+    __extends(SuspendContactRecordingCommand, _super);
+    function SuspendContactRecordingCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    SuspendContactRecordingCommand.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 = "ConnectClient";
-        const commandName = "SuspendContactRecordingCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "SuspendContactRecordingCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: SuspendContactRecordingRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SuspendContactRecordingResponseFilterSensitiveLog,
         };
-        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);
+    };
+    SuspendContactRecordingCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1SuspendContactRecordingCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    SuspendContactRecordingCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1SuspendContactRecordingCommand(output, context);
-    }
-}
+    };
+    return SuspendContactRecordingCommand;
+}($Command));
+export { SuspendContactRecordingCommand };

package/dist-es/commands/TagResourceCommand.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 { TagResourceRequestFilterSensitiveLog } from "../models/models_1";
 import { deserializeAws_restJson1TagResourceCommand, serializeAws_restJson1TagResourceCommand, } from "../protocols/Aws_restJson1";
-export class TagResourceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var TagResourceCommand = (function (_super) {
+    __extends(TagResourceCommand, _super);
+    function TagResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    TagResourceCommand.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 = "ConnectClient";
-        const commandName = "TagResourceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "TagResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: TagResourceRequestFilterSensitiveLog,
-            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);
+    };
+    TagResourceCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1TagResourceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    TagResourceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1TagResourceCommand(output, context);
-    }
-}
+    };
+    return TagResourceCommand;
+}($Command));
+export { TagResourceCommand };