@aws-sdk/client-connect 3.181.0 → 3.183.0

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

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

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

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

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

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

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

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

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

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