@aws-sdk/client-connect 3.184.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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