@aws-sdk/client-connect 3.185.0 → 3.188.0

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

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

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

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

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

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

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

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

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

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