@aws-sdk/client-connect 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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