@aws-sdk/client-sqs 3.183.0 → 3.185.0

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

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, CreateQueueResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateQueueCommand, serializeAws_queryCreateQueueCommand } from "../protocols/Aws_query";
-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 = "SQSClient";
-        const commandName = "CreateQueueCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SQSClient";
+        var commandName = "CreateQueueCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateQueueRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateQueueResultFilterSensitiveLog,
         };
-        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_queryCreateQueueCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateQueueCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryCreateQueueCommand(output, context);
-    }
-}
+    };
+    return CreateQueueCommand;
+}($Command));
+export { CreateQueueCommand };

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

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

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

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

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

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

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

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, ListQueuesResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListQueuesCommand, serializeAws_queryListQueuesCommand } from "../protocols/Aws_query";
-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 = "SQSClient";
-        const commandName = "ListQueuesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SQSClient";
+        var commandName = "ListQueuesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListQueuesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListQueuesResultFilterSensitiveLog,
         };
-        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_queryListQueuesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListQueuesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListQueuesCommand(output, context);
-    }
-}
+    };
+    return ListQueuesCommand;
+}($Command));
+export { ListQueuesCommand };