@aws-sdk/client-sqs 3.183.0 → 3.185.0

package/dist-es/protocols/Aws_query.js

@@ -1,1052 +1,1403 @@
+import { __assign, __awaiter, __generator, __read, __values } from "tslib";
 import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectString as __expectString, extendedEncodeURIComponent as __extendedEncodeURIComponent, getArrayIfSingleItem as __getArrayIfSingleItem, getValueFromTextNode as __getValueFromTextNode, parseBoolean as __parseBoolean, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { decodeHTML } from "entities";
 import { parse as xmlParse } from "fast-xml-parser";
 import { BatchEntryIdsNotDistinct, BatchRequestTooLong, EmptyBatchRequest, InvalidAttributeName, InvalidBatchEntryId, InvalidIdFormat, InvalidMessageContents, MessageNotInflight, OverLimit, PurgeQueueInProgress, QueueDeletedRecently, QueueDoesNotExist, QueueNameExists, ReceiptHandleIsInvalid, TooManyEntriesInBatchRequest, UnsupportedOperation, } from "../models/models_0";
 import { SQSServiceException as __BaseException } from "../models/SQSServiceException";
-export const serializeAws_queryAddPermissionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryAddPermissionRequest(input, context),
-        Action: "AddPermission",
-        Version: "2012-11-05",
+export var serializeAws_queryAddPermissionCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryAddPermissionRequest(input, context)), { Action: "AddPermission", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_queryChangeMessageVisibilityCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryChangeMessageVisibilityRequest(input, context),
-        Action: "ChangeMessageVisibility",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_queryChangeMessageVisibilityCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryChangeMessageVisibilityRequest(input, context)), { Action: "ChangeMessageVisibility", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_queryChangeMessageVisibilityBatchCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryChangeMessageVisibilityBatchRequest(input, context),
-        Action: "ChangeMessageVisibilityBatch",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_queryChangeMessageVisibilityBatchCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryChangeMessageVisibilityBatchRequest(input, context)), { Action: "ChangeMessageVisibilityBatch", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_queryCreateQueueCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryCreateQueueRequest(input, context),
-        Action: "CreateQueue",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_queryCreateQueueCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryCreateQueueRequest(input, context)), { Action: "CreateQueue", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_queryDeleteMessageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteMessageRequest(input, context),
-        Action: "DeleteMessage",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_queryDeleteMessageCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDeleteMessageRequest(input, context)), { Action: "DeleteMessage", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_queryDeleteMessageBatchCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteMessageBatchRequest(input, context),
-        Action: "DeleteMessageBatch",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_queryDeleteMessageBatchCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDeleteMessageBatchRequest(input, context)), { Action: "DeleteMessageBatch", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_queryDeleteQueueCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteQueueRequest(input, context),
-        Action: "DeleteQueue",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_queryDeleteQueueCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDeleteQueueRequest(input, context)), { Action: "DeleteQueue", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_queryGetQueueAttributesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryGetQueueAttributesRequest(input, context),
-        Action: "GetQueueAttributes",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_queryGetQueueAttributesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryGetQueueAttributesRequest(input, context)), { Action: "GetQueueAttributes", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_queryGetQueueUrlCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryGetQueueUrlRequest(input, context),
-        Action: "GetQueueUrl",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_queryGetQueueUrlCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryGetQueueUrlRequest(input, context)), { Action: "GetQueueUrl", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_queryListDeadLetterSourceQueuesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryListDeadLetterSourceQueuesRequest(input, context),
-        Action: "ListDeadLetterSourceQueues",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_queryListDeadLetterSourceQueuesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryListDeadLetterSourceQueuesRequest(input, context)), { Action: "ListDeadLetterSourceQueues", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_queryListQueuesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryListQueuesRequest(input, context),
-        Action: "ListQueues",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_queryListQueuesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryListQueuesRequest(input, context)), { Action: "ListQueues", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_queryListQueueTagsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryListQueueTagsRequest(input, context),
-        Action: "ListQueueTags",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_queryListQueueTagsCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryListQueueTagsRequest(input, context)), { Action: "ListQueueTags", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_queryPurgeQueueCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryPurgeQueueRequest(input, context),
-        Action: "PurgeQueue",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_queryPurgeQueueCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryPurgeQueueRequest(input, context)), { Action: "PurgeQueue", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_queryReceiveMessageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryReceiveMessageRequest(input, context),
-        Action: "ReceiveMessage",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_queryReceiveMessageCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryReceiveMessageRequest(input, context)), { Action: "ReceiveMessage", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_queryRemovePermissionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryRemovePermissionRequest(input, context),
-        Action: "RemovePermission",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_queryRemovePermissionCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryRemovePermissionRequest(input, context)), { Action: "RemovePermission", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_querySendMessageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_querySendMessageRequest(input, context),
-        Action: "SendMessage",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_querySendMessageCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_querySendMessageRequest(input, context)), { Action: "SendMessage", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_querySendMessageBatchCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_querySendMessageBatchRequest(input, context),
-        Action: "SendMessageBatch",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_querySendMessageBatchCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_querySendMessageBatchRequest(input, context)), { Action: "SendMessageBatch", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_querySetQueueAttributesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_querySetQueueAttributesRequest(input, context),
-        Action: "SetQueueAttributes",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_querySetQueueAttributesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_querySetQueueAttributesRequest(input, context)), { Action: "SetQueueAttributes", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_queryTagQueueCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryTagQueueRequest(input, context),
-        Action: "TagQueue",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_queryTagQueueCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryTagQueueRequest(input, context)), { Action: "TagQueue", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_queryUntagQueueCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-www-form-urlencoded",
-    };
-    let body;
-    body = buildFormUrlencodedString({
-        ...serializeAws_queryUntagQueueRequest(input, context),
-        Action: "UntagQueue",
-        Version: "2012-11-05",
+}); };
+export var serializeAws_queryUntagQueueCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryUntagQueueRequest(input, context)), { Action: "UntagQueue", Version: "2012-11-05" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const deserializeAws_queryAddPermissionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryAddPermissionCommandError(output, context);
-    }
-    await collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryAddPermissionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "OverLimit":
-        case "com.amazonaws.sqs#OverLimit":
-            throw await deserializeAws_queryOverLimitResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_queryChangeMessageVisibilityCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryChangeMessageVisibilityCommandError(output, context);
-    }
-    await collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryChangeMessageVisibilityCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AWS.SimpleQueueService.MessageNotInflight":
-        case "com.amazonaws.sqs#MessageNotInflight":
-            throw await deserializeAws_queryMessageNotInflightResponse(parsedOutput, context);
-        case "ReceiptHandleIsInvalid":
-        case "com.amazonaws.sqs#ReceiptHandleIsInvalid":
-            throw await deserializeAws_queryReceiptHandleIsInvalidResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_queryChangeMessageVisibilityBatchCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryChangeMessageVisibilityBatchCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_queryChangeMessageVisibilityBatchResult(data.ChangeMessageVisibilityBatchResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryChangeMessageVisibilityBatchCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AWS.SimpleQueueService.BatchEntryIdsNotDistinct":
-        case "com.amazonaws.sqs#BatchEntryIdsNotDistinct":
-            throw await deserializeAws_queryBatchEntryIdsNotDistinctResponse(parsedOutput, context);
-        case "AWS.SimpleQueueService.EmptyBatchRequest":
-        case "com.amazonaws.sqs#EmptyBatchRequest":
-            throw await deserializeAws_queryEmptyBatchRequestResponse(parsedOutput, context);
-        case "AWS.SimpleQueueService.InvalidBatchEntryId":
-        case "com.amazonaws.sqs#InvalidBatchEntryId":
-            throw await deserializeAws_queryInvalidBatchEntryIdResponse(parsedOutput, context);
-        case "AWS.SimpleQueueService.TooManyEntriesInBatchRequest":
-        case "com.amazonaws.sqs#TooManyEntriesInBatchRequest":
-            throw await deserializeAws_queryTooManyEntriesInBatchRequestResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_queryCreateQueueCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryCreateQueueCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_queryCreateQueueResult(data.CreateQueueResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryCreateQueueCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AWS.SimpleQueueService.QueueDeletedRecently":
-        case "com.amazonaws.sqs#QueueDeletedRecently":
-            throw await deserializeAws_queryQueueDeletedRecentlyResponse(parsedOutput, context);
-        case "QueueAlreadyExists":
-        case "com.amazonaws.sqs#QueueNameExists":
-            throw await deserializeAws_queryQueueNameExistsResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_queryDeleteMessageCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteMessageCommandError(output, context);
-    }
-    await collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryDeleteMessageCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidIdFormat":
-        case "com.amazonaws.sqs#InvalidIdFormat":
-            throw await deserializeAws_queryInvalidIdFormatResponse(parsedOutput, context);
-        case "ReceiptHandleIsInvalid":
-        case "com.amazonaws.sqs#ReceiptHandleIsInvalid":
-            throw await deserializeAws_queryReceiptHandleIsInvalidResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_queryDeleteMessageBatchCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteMessageBatchCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_queryDeleteMessageBatchResult(data.DeleteMessageBatchResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryDeleteMessageBatchCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AWS.SimpleQueueService.BatchEntryIdsNotDistinct":
-        case "com.amazonaws.sqs#BatchEntryIdsNotDistinct":
-            throw await deserializeAws_queryBatchEntryIdsNotDistinctResponse(parsedOutput, context);
-        case "AWS.SimpleQueueService.EmptyBatchRequest":
-        case "com.amazonaws.sqs#EmptyBatchRequest":
-            throw await deserializeAws_queryEmptyBatchRequestResponse(parsedOutput, context);
-        case "AWS.SimpleQueueService.InvalidBatchEntryId":
-        case "com.amazonaws.sqs#InvalidBatchEntryId":
-            throw await deserializeAws_queryInvalidBatchEntryIdResponse(parsedOutput, context);
-        case "AWS.SimpleQueueService.TooManyEntriesInBatchRequest":
-        case "com.amazonaws.sqs#TooManyEntriesInBatchRequest":
-            throw await deserializeAws_queryTooManyEntriesInBatchRequestResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_queryDeleteQueueCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteQueueCommandError(output, context);
-    }
-    await collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryDeleteQueueCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    const parsedBody = parsedOutput.body;
-    throwDefaultError({
-        output,
-        parsedBody: parsedBody.Error,
-        exceptionCtor: __BaseException,
-        errorCode,
-    });
-};
-export const deserializeAws_queryGetQueueAttributesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryGetQueueAttributesCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_queryGetQueueAttributesResult(data.GetQueueAttributesResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryGetQueueAttributesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidAttributeName":
-        case "com.amazonaws.sqs#InvalidAttributeName":
-            throw await deserializeAws_queryInvalidAttributeNameResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_queryGetQueueUrlCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryGetQueueUrlCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_queryGetQueueUrlResult(data.GetQueueUrlResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryGetQueueUrlCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AWS.SimpleQueueService.NonExistentQueue":
-        case "com.amazonaws.sqs#QueueDoesNotExist":
-            throw await deserializeAws_queryQueueDoesNotExistResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_queryListDeadLetterSourceQueuesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryListDeadLetterSourceQueuesCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_queryListDeadLetterSourceQueuesResult(data.ListDeadLetterSourceQueuesResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryListDeadLetterSourceQueuesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AWS.SimpleQueueService.NonExistentQueue":
-        case "com.amazonaws.sqs#QueueDoesNotExist":
-            throw await deserializeAws_queryQueueDoesNotExistResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_queryListQueuesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryListQueuesCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_queryListQueuesResult(data.ListQueuesResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryListQueuesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    const parsedBody = parsedOutput.body;
-    throwDefaultError({
-        output,
-        parsedBody: parsedBody.Error,
-        exceptionCtor: __BaseException,
-        errorCode,
-    });
-};
-export const deserializeAws_queryListQueueTagsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryListQueueTagsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_queryListQueueTagsResult(data.ListQueueTagsResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryListQueueTagsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    const parsedBody = parsedOutput.body;
-    throwDefaultError({
-        output,
-        parsedBody: parsedBody.Error,
-        exceptionCtor: __BaseException,
-        errorCode,
-    });
-};
-export const deserializeAws_queryPurgeQueueCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryPurgeQueueCommandError(output, context);
-    }
-    await collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryPurgeQueueCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AWS.SimpleQueueService.NonExistentQueue":
-        case "com.amazonaws.sqs#QueueDoesNotExist":
-            throw await deserializeAws_queryQueueDoesNotExistResponse(parsedOutput, context);
-        case "AWS.SimpleQueueService.PurgeQueueInProgress":
-        case "com.amazonaws.sqs#PurgeQueueInProgress":
-            throw await deserializeAws_queryPurgeQueueInProgressResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_queryReceiveMessageCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryReceiveMessageCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_queryReceiveMessageResult(data.ReceiveMessageResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryReceiveMessageCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "OverLimit":
-        case "com.amazonaws.sqs#OverLimit":
-            throw await deserializeAws_queryOverLimitResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_queryRemovePermissionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryRemovePermissionCommandError(output, context);
-    }
-    await collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryRemovePermissionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    const parsedBody = parsedOutput.body;
-    throwDefaultError({
-        output,
-        parsedBody: parsedBody.Error,
-        exceptionCtor: __BaseException,
-        errorCode,
-    });
-};
-export const deserializeAws_querySendMessageCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_querySendMessageCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_querySendMessageResult(data.SendMessageResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_querySendMessageCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AWS.SimpleQueueService.UnsupportedOperation":
-        case "com.amazonaws.sqs#UnsupportedOperation":
-            throw await deserializeAws_queryUnsupportedOperationResponse(parsedOutput, context);
-        case "InvalidMessageContents":
-        case "com.amazonaws.sqs#InvalidMessageContents":
-            throw await deserializeAws_queryInvalidMessageContentsResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_querySendMessageBatchCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_querySendMessageBatchCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_querySendMessageBatchResult(data.SendMessageBatchResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_querySendMessageBatchCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AWS.SimpleQueueService.BatchEntryIdsNotDistinct":
-        case "com.amazonaws.sqs#BatchEntryIdsNotDistinct":
-            throw await deserializeAws_queryBatchEntryIdsNotDistinctResponse(parsedOutput, context);
-        case "AWS.SimpleQueueService.BatchRequestTooLong":
-        case "com.amazonaws.sqs#BatchRequestTooLong":
-            throw await deserializeAws_queryBatchRequestTooLongResponse(parsedOutput, context);
-        case "AWS.SimpleQueueService.EmptyBatchRequest":
-        case "com.amazonaws.sqs#EmptyBatchRequest":
-            throw await deserializeAws_queryEmptyBatchRequestResponse(parsedOutput, context);
-        case "AWS.SimpleQueueService.InvalidBatchEntryId":
-        case "com.amazonaws.sqs#InvalidBatchEntryId":
-            throw await deserializeAws_queryInvalidBatchEntryIdResponse(parsedOutput, context);
-        case "AWS.SimpleQueueService.TooManyEntriesInBatchRequest":
-        case "com.amazonaws.sqs#TooManyEntriesInBatchRequest":
-            throw await deserializeAws_queryTooManyEntriesInBatchRequestResponse(parsedOutput, context);
-        case "AWS.SimpleQueueService.UnsupportedOperation":
-        case "com.amazonaws.sqs#UnsupportedOperation":
-            throw await deserializeAws_queryUnsupportedOperationResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_querySetQueueAttributesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_querySetQueueAttributesCommandError(output, context);
-    }
-    await collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_querySetQueueAttributesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidAttributeName":
-        case "com.amazonaws.sqs#InvalidAttributeName":
-            throw await deserializeAws_queryInvalidAttributeNameResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_queryTagQueueCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryTagQueueCommandError(output, context);
+}); };
+export var deserializeAws_queryAddPermissionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryAddPermissionCommandError(output, context)];
+                }
+                return [4, collectBody(output.body, context)];
+            case 1:
+                _a.sent();
+                response = {
+                    $metadata: deserializeMetadata(output),
+                };
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryAddPermissionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "OverLimit": return [3, 2];
+                    case "com.amazonaws.sqs#OverLimit": return [3, 2];
+                }
+                return [3, 4];
+            case 2: return [4, deserializeAws_queryOverLimitResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 5;
+            case 5: return [2];
+        }
+    });
+}); };
+export var deserializeAws_queryChangeMessageVisibilityCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryChangeMessageVisibilityCommandError(output, context)];
+                }
+                return [4, collectBody(output.body, context)];
+            case 1:
+                _a.sent();
+                response = {
+                    $metadata: deserializeMetadata(output),
+                };
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryChangeMessageVisibilityCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "AWS.SimpleQueueService.MessageNotInflight": return [3, 2];
+                    case "com.amazonaws.sqs#MessageNotInflight": return [3, 2];
+                    case "ReceiptHandleIsInvalid": return [3, 4];
+                    case "com.amazonaws.sqs#ReceiptHandleIsInvalid": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_queryMessageNotInflightResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_queryReceiptHandleIsInvalidResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_queryChangeMessageVisibilityBatchCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryChangeMessageVisibilityBatchCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_queryChangeMessageVisibilityBatchResult(data.ChangeMessageVisibilityBatchResult, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryChangeMessageVisibilityBatchCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "AWS.SimpleQueueService.BatchEntryIdsNotDistinct": return [3, 2];
+                    case "com.amazonaws.sqs#BatchEntryIdsNotDistinct": return [3, 2];
+                    case "AWS.SimpleQueueService.EmptyBatchRequest": return [3, 4];
+                    case "com.amazonaws.sqs#EmptyBatchRequest": return [3, 4];
+                    case "AWS.SimpleQueueService.InvalidBatchEntryId": return [3, 6];
+                    case "com.amazonaws.sqs#InvalidBatchEntryId": return [3, 6];
+                    case "AWS.SimpleQueueService.TooManyEntriesInBatchRequest": return [3, 8];
+                    case "com.amazonaws.sqs#TooManyEntriesInBatchRequest": return [3, 8];
+                }
+                return [3, 10];
+            case 2: return [4, deserializeAws_queryBatchEntryIdsNotDistinctResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_queryEmptyBatchRequestResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_queryInvalidBatchEntryIdResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_queryTooManyEntriesInBatchRequestResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 11;
+            case 11: return [2];
+        }
+    });
+}); };
+export var deserializeAws_queryCreateQueueCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryCreateQueueCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_queryCreateQueueResult(data.CreateQueueResult, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryCreateQueueCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "AWS.SimpleQueueService.QueueDeletedRecently": return [3, 2];
+                    case "com.amazonaws.sqs#QueueDeletedRecently": return [3, 2];
+                    case "QueueAlreadyExists": return [3, 4];
+                    case "com.amazonaws.sqs#QueueNameExists": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_queryQueueDeletedRecentlyResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_queryQueueNameExistsResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_queryDeleteMessageCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryDeleteMessageCommandError(output, context)];
+                }
+                return [4, collectBody(output.body, context)];
+            case 1:
+                _a.sent();
+                response = {
+                    $metadata: deserializeMetadata(output),
+                };
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryDeleteMessageCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidIdFormat": return [3, 2];
+                    case "com.amazonaws.sqs#InvalidIdFormat": return [3, 2];
+                    case "ReceiptHandleIsInvalid": return [3, 4];
+                    case "com.amazonaws.sqs#ReceiptHandleIsInvalid": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_queryInvalidIdFormatResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_queryReceiptHandleIsInvalidResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_queryDeleteMessageBatchCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryDeleteMessageBatchCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_queryDeleteMessageBatchResult(data.DeleteMessageBatchResult, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryDeleteMessageBatchCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "AWS.SimpleQueueService.BatchEntryIdsNotDistinct": return [3, 2];
+                    case "com.amazonaws.sqs#BatchEntryIdsNotDistinct": return [3, 2];
+                    case "AWS.SimpleQueueService.EmptyBatchRequest": return [3, 4];
+                    case "com.amazonaws.sqs#EmptyBatchRequest": return [3, 4];
+                    case "AWS.SimpleQueueService.InvalidBatchEntryId": return [3, 6];
+                    case "com.amazonaws.sqs#InvalidBatchEntryId": return [3, 6];
+                    case "AWS.SimpleQueueService.TooManyEntriesInBatchRequest": return [3, 8];
+                    case "com.amazonaws.sqs#TooManyEntriesInBatchRequest": return [3, 8];
+                }
+                return [3, 10];
+            case 2: return [4, deserializeAws_queryBatchEntryIdsNotDistinctResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_queryEmptyBatchRequestResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_queryInvalidBatchEntryIdResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_queryTooManyEntriesInBatchRequestResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 11;
+            case 11: return [2];
+        }
+    });
+}); };
+export var deserializeAws_queryDeleteQueueCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryDeleteQueueCommandError(output, context)];
+                }
+                return [4, collectBody(output.body, context)];
+            case 1:
+                _a.sent();
+                response = {
+                    $metadata: deserializeMetadata(output),
+                };
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryDeleteQueueCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, parsedBody;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                return [2];
+        }
+    });
+}); };
+export var deserializeAws_queryGetQueueAttributesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryGetQueueAttributesCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_queryGetQueueAttributesResult(data.GetQueueAttributesResult, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryGetQueueAttributesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidAttributeName": return [3, 2];
+                    case "com.amazonaws.sqs#InvalidAttributeName": return [3, 2];
+                }
+                return [3, 4];
+            case 2: return [4, deserializeAws_queryInvalidAttributeNameResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 5;
+            case 5: return [2];
+        }
+    });
+}); };
+export var deserializeAws_queryGetQueueUrlCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryGetQueueUrlCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_queryGetQueueUrlResult(data.GetQueueUrlResult, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryGetQueueUrlCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "AWS.SimpleQueueService.NonExistentQueue": return [3, 2];
+                    case "com.amazonaws.sqs#QueueDoesNotExist": return [3, 2];
+                }
+                return [3, 4];
+            case 2: return [4, deserializeAws_queryQueueDoesNotExistResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 5;
+            case 5: return [2];
+        }
+    });
+}); };
+export var deserializeAws_queryListDeadLetterSourceQueuesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryListDeadLetterSourceQueuesCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_queryListDeadLetterSourceQueuesResult(data.ListDeadLetterSourceQueuesResult, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryListDeadLetterSourceQueuesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "AWS.SimpleQueueService.NonExistentQueue": return [3, 2];
+                    case "com.amazonaws.sqs#QueueDoesNotExist": return [3, 2];
+                }
+                return [3, 4];
+            case 2: return [4, deserializeAws_queryQueueDoesNotExistResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 5;
+            case 5: return [2];
+        }
+    });
+}); };
+export var deserializeAws_queryListQueuesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryListQueuesCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_queryListQueuesResult(data.ListQueuesResult, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryListQueuesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, parsedBody;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                return [2];
+        }
+    });
+}); };
+export var deserializeAws_queryListQueueTagsCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryListQueueTagsCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_queryListQueueTagsResult(data.ListQueueTagsResult, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryListQueueTagsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, parsedBody;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                return [2];
+        }
+    });
+}); };
+export var deserializeAws_queryPurgeQueueCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryPurgeQueueCommandError(output, context)];
+                }
+                return [4, collectBody(output.body, context)];
+            case 1:
+                _a.sent();
+                response = {
+                    $metadata: deserializeMetadata(output),
+                };
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryPurgeQueueCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "AWS.SimpleQueueService.NonExistentQueue": return [3, 2];
+                    case "com.amazonaws.sqs#QueueDoesNotExist": return [3, 2];
+                    case "AWS.SimpleQueueService.PurgeQueueInProgress": return [3, 4];
+                    case "com.amazonaws.sqs#PurgeQueueInProgress": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_queryQueueDoesNotExistResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_queryPurgeQueueInProgressResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_queryReceiveMessageCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryReceiveMessageCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_queryReceiveMessageResult(data.ReceiveMessageResult, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryReceiveMessageCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "OverLimit": return [3, 2];
+                    case "com.amazonaws.sqs#OverLimit": return [3, 2];
+                }
+                return [3, 4];
+            case 2: return [4, deserializeAws_queryOverLimitResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 5;
+            case 5: return [2];
+        }
+    });
+}); };
+export var deserializeAws_queryRemovePermissionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryRemovePermissionCommandError(output, context)];
+                }
+                return [4, collectBody(output.body, context)];
+            case 1:
+                _a.sent();
+                response = {
+                    $metadata: deserializeMetadata(output),
+                };
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryRemovePermissionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, parsedBody;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                return [2];
+        }
+    });
+}); };
+export var deserializeAws_querySendMessageCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_querySendMessageCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_querySendMessageResult(data.SendMessageResult, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_querySendMessageCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "AWS.SimpleQueueService.UnsupportedOperation": return [3, 2];
+                    case "com.amazonaws.sqs#UnsupportedOperation": return [3, 2];
+                    case "InvalidMessageContents": return [3, 4];
+                    case "com.amazonaws.sqs#InvalidMessageContents": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_queryUnsupportedOperationResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_queryInvalidMessageContentsResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_querySendMessageBatchCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_querySendMessageBatchCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_querySendMessageBatchResult(data.SendMessageBatchResult, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_querySendMessageBatchCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "AWS.SimpleQueueService.BatchEntryIdsNotDistinct": return [3, 2];
+                    case "com.amazonaws.sqs#BatchEntryIdsNotDistinct": return [3, 2];
+                    case "AWS.SimpleQueueService.BatchRequestTooLong": return [3, 4];
+                    case "com.amazonaws.sqs#BatchRequestTooLong": return [3, 4];
+                    case "AWS.SimpleQueueService.EmptyBatchRequest": return [3, 6];
+                    case "com.amazonaws.sqs#EmptyBatchRequest": return [3, 6];
+                    case "AWS.SimpleQueueService.InvalidBatchEntryId": return [3, 8];
+                    case "com.amazonaws.sqs#InvalidBatchEntryId": return [3, 8];
+                    case "AWS.SimpleQueueService.TooManyEntriesInBatchRequest": return [3, 10];
+                    case "com.amazonaws.sqs#TooManyEntriesInBatchRequest": return [3, 10];
+                    case "AWS.SimpleQueueService.UnsupportedOperation": return [3, 12];
+                    case "com.amazonaws.sqs#UnsupportedOperation": return [3, 12];
+                }
+                return [3, 14];
+            case 2: return [4, deserializeAws_queryBatchEntryIdsNotDistinctResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_queryBatchRequestTooLongResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_queryEmptyBatchRequestResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_queryInvalidBatchEntryIdResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10: return [4, deserializeAws_queryTooManyEntriesInBatchRequestResponse(parsedOutput, context)];
+            case 11: throw _d.sent();
+            case 12: return [4, deserializeAws_queryUnsupportedOperationResponse(parsedOutput, context)];
+            case 13: throw _d.sent();
+            case 14:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 15;
+            case 15: return [2];
+        }
+    });
+}); };
+export var deserializeAws_querySetQueueAttributesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_querySetQueueAttributesCommandError(output, context)];
+                }
+                return [4, collectBody(output.body, context)];
+            case 1:
+                _a.sent();
+                response = {
+                    $metadata: deserializeMetadata(output),
+                };
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_querySetQueueAttributesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidAttributeName": return [3, 2];
+                    case "com.amazonaws.sqs#InvalidAttributeName": return [3, 2];
+                }
+                return [3, 4];
+            case 2: return [4, deserializeAws_queryInvalidAttributeNameResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 5;
+            case 5: return [2];
+        }
+    });
+}); };
+export var deserializeAws_queryTagQueueCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryTagQueueCommandError(output, context)];
+                }
+                return [4, collectBody(output.body, context)];
+            case 1:
+                _a.sent();
+                response = {
+                    $metadata: deserializeMetadata(output),
+                };
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryTagQueueCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, parsedBody;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                return [2];
+        }
+    });
+}); };
+export var deserializeAws_queryUntagQueueCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryUntagQueueCommandError(output, context)];
+                }
+                return [4, collectBody(output.body, context)];
+            case 1:
+                _a.sent();
+                response = {
+                    $metadata: deserializeMetadata(output),
+                };
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryUntagQueueCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, parsedBody;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody.Error,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                return [2];
+        }
+    });
+}); };
+var deserializeAws_queryBatchEntryIdsNotDistinctResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_queryBatchEntryIdsNotDistinct(body.Error, context);
+        exception = new BatchEntryIdsNotDistinct(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_queryBatchRequestTooLongResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_queryBatchRequestTooLong(body.Error, context);
+        exception = new BatchRequestTooLong(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_queryEmptyBatchRequestResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_queryEmptyBatchRequest(body.Error, context);
+        exception = new EmptyBatchRequest(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_queryInvalidAttributeNameResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_queryInvalidAttributeName(body.Error, context);
+        exception = new InvalidAttributeName(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_queryInvalidBatchEntryIdResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_queryInvalidBatchEntryId(body.Error, context);
+        exception = new InvalidBatchEntryId(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_queryInvalidIdFormatResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_queryInvalidIdFormat(body.Error, context);
+        exception = new InvalidIdFormat(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_queryInvalidMessageContentsResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_queryInvalidMessageContents(body.Error, context);
+        exception = new InvalidMessageContents(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_queryMessageNotInflightResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_queryMessageNotInflight(body.Error, context);
+        exception = new MessageNotInflight(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_queryOverLimitResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_queryOverLimit(body.Error, context);
+        exception = new OverLimit(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_queryPurgeQueueInProgressResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_queryPurgeQueueInProgress(body.Error, context);
+        exception = new PurgeQueueInProgress(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_queryQueueDeletedRecentlyResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_queryQueueDeletedRecently(body.Error, context);
+        exception = new QueueDeletedRecently(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_queryQueueDoesNotExistResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_queryQueueDoesNotExist(body.Error, context);
+        exception = new QueueDoesNotExist(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_queryQueueNameExistsResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_queryQueueNameExists(body.Error, context);
+        exception = new QueueNameExists(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_queryReceiptHandleIsInvalidResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_queryReceiptHandleIsInvalid(body.Error, context);
+        exception = new ReceiptHandleIsInvalid(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_queryTooManyEntriesInBatchRequestResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_queryTooManyEntriesInBatchRequest(body.Error, context);
+        exception = new TooManyEntriesInBatchRequest(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_queryUnsupportedOperationResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_queryUnsupportedOperation(body.Error, context);
+        exception = new UnsupportedOperation(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var serializeAws_queryActionNameList = function (input, context) {
+    var e_1, _a;
+    var entries = {};
+    var counter = 1;
+    try {
+        for (var input_1 = __values(input), input_1_1 = input_1.next(); !input_1_1.done; input_1_1 = input_1.next()) {
+            var entry = input_1_1.value;
+            if (entry === null) {
+                continue;
+            }
+            entries["member.".concat(counter)] = entry;
+            counter++;
+        }
     }
-    await collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryTagQueueCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    const parsedBody = parsedOutput.body;
-    throwDefaultError({
-        output,
-        parsedBody: parsedBody.Error,
-        exceptionCtor: __BaseException,
-        errorCode,
-    });
-};
-export const deserializeAws_queryUntagQueueCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_queryUntagQueueCommandError(output, context);
-    }
-    await collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_queryUntagQueueCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    const parsedBody = parsedOutput.body;
-    throwDefaultError({
-        output,
-        parsedBody: parsedBody.Error,
-        exceptionCtor: __BaseException,
-        errorCode,
-    });
-};
-const deserializeAws_queryBatchEntryIdsNotDistinctResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryBatchEntryIdsNotDistinct(body.Error, context);
-    const exception = new BatchEntryIdsNotDistinct({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_queryBatchRequestTooLongResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryBatchRequestTooLong(body.Error, context);
-    const exception = new BatchRequestTooLong({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_queryEmptyBatchRequestResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryEmptyBatchRequest(body.Error, context);
-    const exception = new EmptyBatchRequest({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_queryInvalidAttributeNameResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidAttributeName(body.Error, context);
-    const exception = new InvalidAttributeName({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_queryInvalidBatchEntryIdResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidBatchEntryId(body.Error, context);
-    const exception = new InvalidBatchEntryId({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_queryInvalidIdFormatResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidIdFormat(body.Error, context);
-    const exception = new InvalidIdFormat({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_queryInvalidMessageContentsResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidMessageContents(body.Error, context);
-    const exception = new InvalidMessageContents({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_queryMessageNotInflightResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryMessageNotInflight(body.Error, context);
-    const exception = new MessageNotInflight({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_queryOverLimitResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryOverLimit(body.Error, context);
-    const exception = new OverLimit({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_queryPurgeQueueInProgressResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryPurgeQueueInProgress(body.Error, context);
-    const exception = new PurgeQueueInProgress({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_queryQueueDeletedRecentlyResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryQueueDeletedRecently(body.Error, context);
-    const exception = new QueueDeletedRecently({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_queryQueueDoesNotExistResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryQueueDoesNotExist(body.Error, context);
-    const exception = new QueueDoesNotExist({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_queryQueueNameExistsResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryQueueNameExists(body.Error, context);
-    const exception = new QueueNameExists({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_queryReceiptHandleIsInvalidResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryReceiptHandleIsInvalid(body.Error, context);
-    const exception = new ReceiptHandleIsInvalid({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_queryTooManyEntriesInBatchRequestResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryTooManyEntriesInBatchRequest(body.Error, context);
-    const exception = new TooManyEntriesInBatchRequest({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_queryUnsupportedOperationResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryUnsupportedOperation(body.Error, context);
-    const exception = new UnsupportedOperation({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const serializeAws_queryActionNameList = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
-        }
-        entries[`member.${counter}`] = entry;
-        counter++;
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (input_1_1 && !input_1_1.done && (_a = input_1.return)) _a.call(input_1);
+        }
+        finally { if (e_1) throw e_1.error; }
     }
     return entries;
 };
-const serializeAws_queryAddPermissionRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryAddPermissionRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
@@ -1054,73 +1405,109 @@ const serializeAws_queryAddPermissionRequest = (input, context) => {
         entries["Label"] = input.Label;
     }
     if (input.AWSAccountIds != null) {
-        const memberEntries = serializeAws_queryAWSAccountIdList(input.AWSAccountIds, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `AWSAccountId.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryAWSAccountIdList(input.AWSAccountIds, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "AWSAccountId.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
     if (input.Actions != null) {
-        const memberEntries = serializeAws_queryActionNameList(input.Actions, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `ActionName.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryActionNameList(input.Actions, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "ActionName.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
     return entries;
 };
-const serializeAws_queryAttributeNameList = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
+var serializeAws_queryAttributeNameList = function (input, context) {
+    var e_2, _a;
+    var entries = {};
+    var counter = 1;
+    try {
+        for (var input_2 = __values(input), input_2_1 = input_2.next(); !input_2_1.done; input_2_1 = input_2.next()) {
+            var entry = input_2_1.value;
+            if (entry === null) {
+                continue;
+            }
+            entries["member.".concat(counter)] = entry;
+            counter++;
         }
-        entries[`member.${counter}`] = entry;
-        counter++;
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (input_2_1 && !input_2_1.done && (_a = input_2.return)) _a.call(input_2);
+        }
+        finally { if (e_2) throw e_2.error; }
     }
     return entries;
 };
-const serializeAws_queryAWSAccountIdList = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
+var serializeAws_queryAWSAccountIdList = function (input, context) {
+    var e_3, _a;
+    var entries = {};
+    var counter = 1;
+    try {
+        for (var input_3 = __values(input), input_3_1 = input_3.next(); !input_3_1.done; input_3_1 = input_3.next()) {
+            var entry = input_3_1.value;
+            if (entry === null) {
+                continue;
+            }
+            entries["member.".concat(counter)] = entry;
+            counter++;
         }
-        entries[`member.${counter}`] = entry;
-        counter++;
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (input_3_1 && !input_3_1.done && (_a = input_3.return)) _a.call(input_3);
+        }
+        finally { if (e_3) throw e_3.error; }
     }
     return entries;
 };
-const serializeAws_queryBinaryList = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
+var serializeAws_queryBinaryList = function (input, context) {
+    var e_4, _a;
+    var entries = {};
+    var counter = 1;
+    try {
+        for (var input_4 = __values(input), input_4_1 = input_4.next(); !input_4_1.done; input_4_1 = input_4.next()) {
+            var entry = input_4_1.value;
+            if (entry === null) {
+                continue;
+            }
+            entries["BinaryListValue.".concat(counter)] = context.base64Encoder(entry);
+            counter++;
         }
-        entries[`BinaryListValue.${counter}`] = context.base64Encoder(entry);
-        counter++;
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (input_4_1 && !input_4_1.done && (_a = input_4.return)) _a.call(input_4);
+        }
+        finally { if (e_4) throw e_4.error; }
     }
     return entries;
 };
-const serializeAws_queryChangeMessageVisibilityBatchRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryChangeMessageVisibilityBatchRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.Entries != null) {
-        const memberEntries = serializeAws_queryChangeMessageVisibilityBatchRequestEntryList(input.Entries, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `ChangeMessageVisibilityBatchRequestEntry.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryChangeMessageVisibilityBatchRequestEntryList(input.Entries, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "ChangeMessageVisibilityBatchRequestEntry.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
     return entries;
 };
-const serializeAws_queryChangeMessageVisibilityBatchRequestEntry = (input, context) => {
-    const entries = {};
+var serializeAws_queryChangeMessageVisibilityBatchRequestEntry = function (input, context) {
+    var entries = {};
     if (input.Id != null) {
         entries["Id"] = input.Id;
     }
@@ -1132,23 +1519,35 @@ const serializeAws_queryChangeMessageVisibilityBatchRequestEntry = (input, conte
     }
     return entries;
 };
-const serializeAws_queryChangeMessageVisibilityBatchRequestEntryList = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
+var serializeAws_queryChangeMessageVisibilityBatchRequestEntryList = function (input, context) {
+    var e_5, _a;
+    var entries = {};
+    var counter = 1;
+    try {
+        for (var input_5 = __values(input), input_5_1 = input_5.next(); !input_5_1.done; input_5_1 = input_5.next()) {
+            var entry = input_5_1.value;
+            if (entry === null) {
+                continue;
+            }
+            var memberEntries = serializeAws_queryChangeMessageVisibilityBatchRequestEntry(entry, context);
+            Object.entries(memberEntries).forEach(function (_a) {
+                var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                entries["member.".concat(counter, ".").concat(key)] = value;
+            });
+            counter++;
         }
-        const memberEntries = serializeAws_queryChangeMessageVisibilityBatchRequestEntry(entry, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            entries[`member.${counter}.${key}`] = value;
-        });
-        counter++;
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (input_5_1 && !input_5_1.done && (_a = input_5.return)) _a.call(input_5);
+        }
+        finally { if (e_5) throw e_5.error; }
     }
     return entries;
 };
-const serializeAws_queryChangeMessageVisibilityRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryChangeMessageVisibilityRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
@@ -1160,43 +1559,46 @@ const serializeAws_queryChangeMessageVisibilityRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryCreateQueueRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryCreateQueueRequest = function (input, context) {
+    var entries = {};
     if (input.QueueName != null) {
         entries["QueueName"] = input.QueueName;
     }
     if (input.tags != null) {
-        const memberEntries = serializeAws_queryTagMap(input.tags, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Tag.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryTagMap(input.tags, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "Tag.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
     if (input.Attributes != null) {
-        const memberEntries = serializeAws_queryQueueAttributeMap(input.Attributes, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Attribute.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryQueueAttributeMap(input.Attributes, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "Attribute.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
     return entries;
 };
-const serializeAws_queryDeleteMessageBatchRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryDeleteMessageBatchRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.Entries != null) {
-        const memberEntries = serializeAws_queryDeleteMessageBatchRequestEntryList(input.Entries, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `DeleteMessageBatchRequestEntry.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryDeleteMessageBatchRequestEntryList(input.Entries, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "DeleteMessageBatchRequestEntry.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
     return entries;
 };
-const serializeAws_queryDeleteMessageBatchRequestEntry = (input, context) => {
-    const entries = {};
+var serializeAws_queryDeleteMessageBatchRequestEntry = function (input, context) {
+    var entries = {};
     if (input.Id != null) {
         entries["Id"] = input.Id;
     }
@@ -1205,23 +1607,35 @@ const serializeAws_queryDeleteMessageBatchRequestEntry = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeleteMessageBatchRequestEntryList = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
+var serializeAws_queryDeleteMessageBatchRequestEntryList = function (input, context) {
+    var e_6, _a;
+    var entries = {};
+    var counter = 1;
+    try {
+        for (var input_6 = __values(input), input_6_1 = input_6.next(); !input_6_1.done; input_6_1 = input_6.next()) {
+            var entry = input_6_1.value;
+            if (entry === null) {
+                continue;
+            }
+            var memberEntries = serializeAws_queryDeleteMessageBatchRequestEntry(entry, context);
+            Object.entries(memberEntries).forEach(function (_a) {
+                var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                entries["member.".concat(counter, ".").concat(key)] = value;
+            });
+            counter++;
         }
-        const memberEntries = serializeAws_queryDeleteMessageBatchRequestEntry(entry, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            entries[`member.${counter}.${key}`] = value;
-        });
-        counter++;
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (input_6_1 && !input_6_1.done && (_a = input_6.return)) _a.call(input_6);
+        }
+        finally { if (e_6) throw e_6.error; }
     }
     return entries;
 };
-const serializeAws_queryDeleteMessageRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryDeleteMessageRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
@@ -1230,29 +1644,30 @@ const serializeAws_queryDeleteMessageRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeleteQueueRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryDeleteQueueRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     return entries;
 };
-const serializeAws_queryGetQueueAttributesRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryGetQueueAttributesRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.AttributeNames != null) {
-        const memberEntries = serializeAws_queryAttributeNameList(input.AttributeNames, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `AttributeName.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryAttributeNameList(input.AttributeNames, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "AttributeName.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
     return entries;
 };
-const serializeAws_queryGetQueueUrlRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryGetQueueUrlRequest = function (input, context) {
+    var entries = {};
     if (input.QueueName != null) {
         entries["QueueName"] = input.QueueName;
     }
@@ -1261,8 +1676,8 @@ const serializeAws_queryGetQueueUrlRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryListDeadLetterSourceQueuesRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryListDeadLetterSourceQueuesRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
@@ -1274,8 +1689,8 @@ const serializeAws_queryListDeadLetterSourceQueuesRequest = (input, context) =>
     }
     return entries;
 };
-const serializeAws_queryListQueuesRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryListQueuesRequest = function (input, context) {
+    var entries = {};
     if (input.QueueNamePrefix != null) {
         entries["QueueNamePrefix"] = input.QueueNamePrefix;
     }
@@ -1287,27 +1702,38 @@ const serializeAws_queryListQueuesRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryListQueueTagsRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryListQueueTagsRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     return entries;
 };
-const serializeAws_queryMessageAttributeNameList = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
+var serializeAws_queryMessageAttributeNameList = function (input, context) {
+    var e_7, _a;
+    var entries = {};
+    var counter = 1;
+    try {
+        for (var input_7 = __values(input), input_7_1 = input_7.next(); !input_7_1.done; input_7_1 = input_7.next()) {
+            var entry = input_7_1.value;
+            if (entry === null) {
+                continue;
+            }
+            entries["member.".concat(counter)] = entry;
+            counter++;
         }
-        entries[`member.${counter}`] = entry;
-        counter++;
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (input_7_1 && !input_7_1.done && (_a = input_7.return)) _a.call(input_7);
+        }
+        finally { if (e_7) throw e_7.error; }
     }
     return entries;
 };
-const serializeAws_queryMessageAttributeValue = (input, context) => {
-    const entries = {};
+var serializeAws_queryMessageAttributeValue = function (input, context) {
+    var entries = {};
     if (input.StringValue != null) {
         entries["StringValue"] = input.StringValue;
     }
@@ -1315,16 +1741,18 @@ const serializeAws_queryMessageAttributeValue = (input, context) => {
         entries["BinaryValue"] = context.base64Encoder(input.BinaryValue);
     }
     if (input.StringListValues != null) {
-        const memberEntries = serializeAws_queryStringList(input.StringListValues, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `StringListValue.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryStringList(input.StringListValues, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "StringListValue.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
     if (input.BinaryListValues != null) {
-        const memberEntries = serializeAws_queryBinaryList(input.BinaryListValues, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `BinaryListValue.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryBinaryList(input.BinaryListValues, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "BinaryListValue.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
@@ -1333,38 +1761,40 @@ const serializeAws_queryMessageAttributeValue = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryMessageBodyAttributeMap = (input, context) => {
-    const entries = {};
-    let counter = 1;
+var serializeAws_queryMessageBodyAttributeMap = function (input, context) {
+    var entries = {};
+    var counter = 1;
     Object.keys(input)
-        .filter((key) => input[key] != null)
-        .forEach((key) => {
-        entries[`entry.${counter}.Name`] = key;
-        const memberEntries = serializeAws_queryMessageAttributeValue(input[key], context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            entries[`entry.${counter}.Value.${key}`] = value;
+        .filter(function (key) { return input[key] != null; })
+        .forEach(function (key) {
+        entries["entry.".concat(counter, ".Name")] = key;
+        var memberEntries = serializeAws_queryMessageAttributeValue(input[key], context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            entries["entry.".concat(counter, ".Value.").concat(key)] = value;
         });
         counter++;
     });
     return entries;
 };
-const serializeAws_queryMessageBodySystemAttributeMap = (input, context) => {
-    const entries = {};
-    let counter = 1;
+var serializeAws_queryMessageBodySystemAttributeMap = function (input, context) {
+    var entries = {};
+    var counter = 1;
     Object.keys(input)
-        .filter((key) => input[key] != null)
-        .forEach((key) => {
-        entries[`entry.${counter}.Name`] = key;
-        const memberEntries = serializeAws_queryMessageSystemAttributeValue(input[key], context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            entries[`entry.${counter}.Value.${key}`] = value;
+        .filter(function (key) { return input[key] != null; })
+        .forEach(function (key) {
+        entries["entry.".concat(counter, ".Name")] = key;
+        var memberEntries = serializeAws_queryMessageSystemAttributeValue(input[key], context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            entries["entry.".concat(counter, ".Value.").concat(key)] = value;
         });
         counter++;
     });
     return entries;
 };
-const serializeAws_queryMessageSystemAttributeValue = (input, context) => {
-    const entries = {};
+var serializeAws_queryMessageSystemAttributeValue = function (input, context) {
+    var entries = {};
     if (input.StringValue != null) {
         entries["StringValue"] = input.StringValue;
     }
@@ -1372,16 +1802,18 @@ const serializeAws_queryMessageSystemAttributeValue = (input, context) => {
         entries["BinaryValue"] = context.base64Encoder(input.BinaryValue);
     }
     if (input.StringListValues != null) {
-        const memberEntries = serializeAws_queryStringList(input.StringListValues, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `StringListValue.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryStringList(input.StringListValues, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "StringListValue.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
     if (input.BinaryListValues != null) {
-        const memberEntries = serializeAws_queryBinaryList(input.BinaryListValues, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `BinaryListValue.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryBinaryList(input.BinaryListValues, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "BinaryListValue.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
@@ -1390,41 +1822,43 @@ const serializeAws_queryMessageSystemAttributeValue = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryPurgeQueueRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryPurgeQueueRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     return entries;
 };
-const serializeAws_queryQueueAttributeMap = (input, context) => {
-    const entries = {};
-    let counter = 1;
+var serializeAws_queryQueueAttributeMap = function (input, context) {
+    var entries = {};
+    var counter = 1;
     Object.keys(input)
-        .filter((key) => input[key] != null)
-        .forEach((key) => {
-        entries[`entry.${counter}.Name`] = key;
-        entries[`entry.${counter}.Value`] = input[key];
+        .filter(function (key) { return input[key] != null; })
+        .forEach(function (key) {
+        entries["entry.".concat(counter, ".Name")] = key;
+        entries["entry.".concat(counter, ".Value")] = input[key];
         counter++;
     });
     return entries;
 };
-const serializeAws_queryReceiveMessageRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryReceiveMessageRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.AttributeNames != null) {
-        const memberEntries = serializeAws_queryAttributeNameList(input.AttributeNames, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `AttributeName.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryAttributeNameList(input.AttributeNames, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "AttributeName.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
     if (input.MessageAttributeNames != null) {
-        const memberEntries = serializeAws_queryMessageAttributeNameList(input.MessageAttributeNames, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `MessageAttributeName.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryMessageAttributeNameList(input.MessageAttributeNames, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "MessageAttributeName.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
@@ -1442,8 +1876,8 @@ const serializeAws_queryReceiveMessageRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryRemovePermissionRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryRemovePermissionRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
@@ -1452,22 +1886,23 @@ const serializeAws_queryRemovePermissionRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_querySendMessageBatchRequest = (input, context) => {
-    const entries = {};
+var serializeAws_querySendMessageBatchRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.Entries != null) {
-        const memberEntries = serializeAws_querySendMessageBatchRequestEntryList(input.Entries, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `SendMessageBatchRequestEntry.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_querySendMessageBatchRequestEntryList(input.Entries, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "SendMessageBatchRequestEntry.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
     return entries;
 };
-const serializeAws_querySendMessageBatchRequestEntry = (input, context) => {
-    const entries = {};
+var serializeAws_querySendMessageBatchRequestEntry = function (input, context) {
+    var entries = {};
     if (input.Id != null) {
         entries["Id"] = input.Id;
     }
@@ -1478,16 +1913,18 @@ const serializeAws_querySendMessageBatchRequestEntry = (input, context) => {
         entries["DelaySeconds"] = input.DelaySeconds;
     }
     if (input.MessageAttributes != null) {
-        const memberEntries = serializeAws_queryMessageBodyAttributeMap(input.MessageAttributes, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `MessageAttribute.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryMessageBodyAttributeMap(input.MessageAttributes, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "MessageAttribute.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
     if (input.MessageSystemAttributes != null) {
-        const memberEntries = serializeAws_queryMessageBodySystemAttributeMap(input.MessageSystemAttributes, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `MessageSystemAttribute.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryMessageBodySystemAttributeMap(input.MessageSystemAttributes, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "MessageSystemAttribute.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
@@ -1499,23 +1936,35 @@ const serializeAws_querySendMessageBatchRequestEntry = (input, context) => {
     }
     return entries;
 };
-const serializeAws_querySendMessageBatchRequestEntryList = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
+var serializeAws_querySendMessageBatchRequestEntryList = function (input, context) {
+    var e_8, _a;
+    var entries = {};
+    var counter = 1;
+    try {
+        for (var input_8 = __values(input), input_8_1 = input_8.next(); !input_8_1.done; input_8_1 = input_8.next()) {
+            var entry = input_8_1.value;
+            if (entry === null) {
+                continue;
+            }
+            var memberEntries = serializeAws_querySendMessageBatchRequestEntry(entry, context);
+            Object.entries(memberEntries).forEach(function (_a) {
+                var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                entries["member.".concat(counter, ".").concat(key)] = value;
+            });
+            counter++;
         }
-        const memberEntries = serializeAws_querySendMessageBatchRequestEntry(entry, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            entries[`member.${counter}.${key}`] = value;
-        });
-        counter++;
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (input_8_1 && !input_8_1.done && (_a = input_8.return)) _a.call(input_8);
+        }
+        finally { if (e_8) throw e_8.error; }
     }
     return entries;
 };
-const serializeAws_querySendMessageRequest = (input, context) => {
-    const entries = {};
+var serializeAws_querySendMessageRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
@@ -1526,16 +1975,18 @@ const serializeAws_querySendMessageRequest = (input, context) => {
         entries["DelaySeconds"] = input.DelaySeconds;
     }
     if (input.MessageAttributes != null) {
-        const memberEntries = serializeAws_queryMessageBodyAttributeMap(input.MessageAttributes, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `MessageAttribute.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryMessageBodyAttributeMap(input.MessageAttributes, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "MessageAttribute.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
     if (input.MessageSystemAttributes != null) {
-        const memberEntries = serializeAws_queryMessageBodySystemAttributeMap(input.MessageSystemAttributes, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `MessageSystemAttribute.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryMessageBodySystemAttributeMap(input.MessageSystemAttributes, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "MessageSystemAttribute.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
@@ -1547,94 +1998,119 @@ const serializeAws_querySendMessageRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_querySetQueueAttributesRequest = (input, context) => {
-    const entries = {};
+var serializeAws_querySetQueueAttributesRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.Attributes != null) {
-        const memberEntries = serializeAws_queryQueueAttributeMap(input.Attributes, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Attribute.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryQueueAttributeMap(input.Attributes, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "Attribute.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
     return entries;
 };
-const serializeAws_queryStringList = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
+var serializeAws_queryStringList = function (input, context) {
+    var e_9, _a;
+    var entries = {};
+    var counter = 1;
+    try {
+        for (var input_9 = __values(input), input_9_1 = input_9.next(); !input_9_1.done; input_9_1 = input_9.next()) {
+            var entry = input_9_1.value;
+            if (entry === null) {
+                continue;
+            }
+            entries["StringListValue.".concat(counter)] = entry;
+            counter++;
         }
-        entries[`StringListValue.${counter}`] = entry;
-        counter++;
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (input_9_1 && !input_9_1.done && (_a = input_9.return)) _a.call(input_9);
+        }
+        finally { if (e_9) throw e_9.error; }
     }
     return entries;
 };
-const serializeAws_queryTagKeyList = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
+var serializeAws_queryTagKeyList = function (input, context) {
+    var e_10, _a;
+    var entries = {};
+    var counter = 1;
+    try {
+        for (var input_10 = __values(input), input_10_1 = input_10.next(); !input_10_1.done; input_10_1 = input_10.next()) {
+            var entry = input_10_1.value;
+            if (entry === null) {
+                continue;
+            }
+            entries["member.".concat(counter)] = entry;
+            counter++;
         }
-        entries[`member.${counter}`] = entry;
-        counter++;
+    }
+    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+    finally {
+        try {
+            if (input_10_1 && !input_10_1.done && (_a = input_10.return)) _a.call(input_10);
+        }
+        finally { if (e_10) throw e_10.error; }
     }
     return entries;
 };
-const serializeAws_queryTagMap = (input, context) => {
-    const entries = {};
-    let counter = 1;
+var serializeAws_queryTagMap = function (input, context) {
+    var entries = {};
+    var counter = 1;
     Object.keys(input)
-        .filter((key) => input[key] != null)
-        .forEach((key) => {
-        entries[`entry.${counter}.Key`] = key;
-        entries[`entry.${counter}.Value`] = input[key];
+        .filter(function (key) { return input[key] != null; })
+        .forEach(function (key) {
+        entries["entry.".concat(counter, ".Key")] = key;
+        entries["entry.".concat(counter, ".Value")] = input[key];
         counter++;
     });
     return entries;
 };
-const serializeAws_queryTagQueueRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryTagQueueRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.Tags != null) {
-        const memberEntries = serializeAws_queryTagMap(input.Tags, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Tag.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryTagMap(input.Tags, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "Tag.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
     return entries;
 };
-const serializeAws_queryUntagQueueRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryUntagQueueRequest = function (input, context) {
+    var entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.TagKeys != null) {
-        const memberEntries = serializeAws_queryTagKeyList(input.TagKeys, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `TagKey.${key.substring(key.indexOf(".") + 1)}`;
+        var memberEntries = serializeAws_queryTagKeyList(input.TagKeys, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "TagKey.".concat(key.substring(key.indexOf(".") + 1));
             entries[loc] = value;
         });
     }
     return entries;
 };
-const deserializeAws_queryBatchEntryIdsNotDistinct = (output, context) => {
-    const contents = {};
+var deserializeAws_queryBatchEntryIdsNotDistinct = function (output, context) {
+    var contents = {};
     return contents;
 };
-const deserializeAws_queryBatchRequestTooLong = (output, context) => {
-    const contents = {};
+var deserializeAws_queryBatchRequestTooLong = function (output, context) {
+    var contents = {};
     return contents;
 };
-const deserializeAws_queryBatchResultErrorEntry = (output, context) => {
-    const contents = {
+var deserializeAws_queryBatchResultErrorEntry = function (output, context) {
+    var contents = {
         Id: undefined,
         SenderFault: undefined,
         Code: undefined,
@@ -1654,22 +2130,22 @@ const deserializeAws_queryBatchResultErrorEntry = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryBatchResultErrorEntryList = (output, context) => {
+var deserializeAws_queryBatchResultErrorEntryList = function (output, context) {
     return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return deserializeAws_queryBatchResultErrorEntry(entry, context);
     });
 };
-const deserializeAws_queryBinaryList = (output, context) => {
+var deserializeAws_queryBinaryList = function (output, context) {
     return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return context.base64Decoder(entry);
     });
 };
-const deserializeAws_queryChangeMessageVisibilityBatchResult = (output, context) => {
-    const contents = {
+var deserializeAws_queryChangeMessageVisibilityBatchResult = function (output, context) {
+    var contents = {
         Successful: undefined,
         Failed: undefined,
     };
@@ -1687,8 +2163,8 @@ const deserializeAws_queryChangeMessageVisibilityBatchResult = (output, context)
     }
     return contents;
 };
-const deserializeAws_queryChangeMessageVisibilityBatchResultEntry = (output, context) => {
-    const contents = {
+var deserializeAws_queryChangeMessageVisibilityBatchResultEntry = function (output, context) {
+    var contents = {
         Id: undefined,
     };
     if (output["Id"] !== undefined) {
@@ -1696,15 +2172,15 @@ const deserializeAws_queryChangeMessageVisibilityBatchResultEntry = (output, con
     }
     return contents;
 };
-const deserializeAws_queryChangeMessageVisibilityBatchResultEntryList = (output, context) => {
+var deserializeAws_queryChangeMessageVisibilityBatchResultEntryList = function (output, context) {
     return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return deserializeAws_queryChangeMessageVisibilityBatchResultEntry(entry, context);
     });
 };
-const deserializeAws_queryCreateQueueResult = (output, context) => {
-    const contents = {
+var deserializeAws_queryCreateQueueResult = function (output, context) {
+    var contents = {
         QueueUrl: undefined,
     };
     if (output["QueueUrl"] !== undefined) {
@@ -1712,8 +2188,8 @@ const deserializeAws_queryCreateQueueResult = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryDeleteMessageBatchResult = (output, context) => {
-    const contents = {
+var deserializeAws_queryDeleteMessageBatchResult = function (output, context) {
+    var contents = {
         Successful: undefined,
         Failed: undefined,
     };
@@ -1731,8 +2207,8 @@ const deserializeAws_queryDeleteMessageBatchResult = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryDeleteMessageBatchResultEntry = (output, context) => {
-    const contents = {
+var deserializeAws_queryDeleteMessageBatchResultEntry = function (output, context) {
+    var contents = {
         Id: undefined,
     };
     if (output["Id"] !== undefined) {
@@ -1740,19 +2216,19 @@ const deserializeAws_queryDeleteMessageBatchResultEntry = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryDeleteMessageBatchResultEntryList = (output, context) => {
+var deserializeAws_queryDeleteMessageBatchResultEntryList = function (output, context) {
     return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return deserializeAws_queryDeleteMessageBatchResultEntry(entry, context);
     });
 };
-const deserializeAws_queryEmptyBatchRequest = (output, context) => {
-    const contents = {};
+var deserializeAws_queryEmptyBatchRequest = function (output, context) {
+    var contents = {};
     return contents;
 };
-const deserializeAws_queryGetQueueAttributesResult = (output, context) => {
-    const contents = {
+var deserializeAws_queryGetQueueAttributesResult = function (output, context) {
+    var contents = {
         Attributes: undefined,
     };
     if (output.Attribute === "") {
@@ -1763,8 +2239,8 @@ const deserializeAws_queryGetQueueAttributesResult = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryGetQueueUrlResult = (output, context) => {
-    const contents = {
+var deserializeAws_queryGetQueueUrlResult = function (output, context) {
+    var contents = {
         QueueUrl: undefined,
     };
     if (output["QueueUrl"] !== undefined) {
@@ -1772,24 +2248,24 @@ const deserializeAws_queryGetQueueUrlResult = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryInvalidAttributeName = (output, context) => {
-    const contents = {};
+var deserializeAws_queryInvalidAttributeName = function (output, context) {
+    var contents = {};
     return contents;
 };
-const deserializeAws_queryInvalidBatchEntryId = (output, context) => {
-    const contents = {};
+var deserializeAws_queryInvalidBatchEntryId = function (output, context) {
+    var contents = {};
     return contents;
 };
-const deserializeAws_queryInvalidIdFormat = (output, context) => {
-    const contents = {};
+var deserializeAws_queryInvalidIdFormat = function (output, context) {
+    var contents = {};
     return contents;
 };
-const deserializeAws_queryInvalidMessageContents = (output, context) => {
-    const contents = {};
+var deserializeAws_queryInvalidMessageContents = function (output, context) {
+    var contents = {};
     return contents;
 };
-const deserializeAws_queryListDeadLetterSourceQueuesResult = (output, context) => {
-    const contents = {
+var deserializeAws_queryListDeadLetterSourceQueuesResult = function (output, context) {
+    var contents = {
         queueUrls: undefined,
         NextToken: undefined,
     };
@@ -1804,8 +2280,8 @@ const deserializeAws_queryListDeadLetterSourceQueuesResult = (output, context) =
     }
     return contents;
 };
-const deserializeAws_queryListQueuesResult = (output, context) => {
-    const contents = {
+var deserializeAws_queryListQueuesResult = function (output, context) {
+    var contents = {
         NextToken: undefined,
         QueueUrls: undefined,
     };
@@ -1820,8 +2296,8 @@ const deserializeAws_queryListQueuesResult = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryListQueueTagsResult = (output, context) => {
-    const contents = {
+var deserializeAws_queryListQueueTagsResult = function (output, context) {
+    var contents = {
         Tags: undefined,
     };
     if (output.Tag === "") {
@@ -1832,8 +2308,8 @@ const deserializeAws_queryListQueueTagsResult = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryMessage = (output, context) => {
-    const contents = {
+var deserializeAws_queryMessage = function (output, context) {
+    var contents = {
         MessageId: undefined,
         ReceiptHandle: undefined,
         MD5OfBody: undefined,
@@ -1871,8 +2347,8 @@ const deserializeAws_queryMessage = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryMessageAttributeValue = (output, context) => {
-    const contents = {
+var deserializeAws_queryMessageAttributeValue = function (output, context) {
+    var contents = {
         StringValue: undefined,
         BinaryValue: undefined,
         StringListValues: undefined,
@@ -1902,83 +2378,77 @@ const deserializeAws_queryMessageAttributeValue = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryMessageBodyAttributeMap = (output, context) => {
-    return output.reduce((acc, pair) => {
+var deserializeAws_queryMessageBodyAttributeMap = function (output, context) {
+    return output.reduce(function (acc, pair) {
+        var _a;
         if (pair["Value"] === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [pair["Name"]]: deserializeAws_queryMessageAttributeValue(pair["Value"], context),
-        };
+        return __assign(__assign({}, acc), (_a = {}, _a[pair["Name"]] = deserializeAws_queryMessageAttributeValue(pair["Value"], context), _a));
     }, {});
 };
-const deserializeAws_queryMessageList = (output, context) => {
+var deserializeAws_queryMessageList = function (output, context) {
     return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return deserializeAws_queryMessage(entry, context);
     });
 };
-const deserializeAws_queryMessageNotInflight = (output, context) => {
-    const contents = {};
+var deserializeAws_queryMessageNotInflight = function (output, context) {
+    var contents = {};
     return contents;
 };
-const deserializeAws_queryMessageSystemAttributeMap = (output, context) => {
-    return output.reduce((acc, pair) => {
+var deserializeAws_queryMessageSystemAttributeMap = function (output, context) {
+    return output.reduce(function (acc, pair) {
+        var _a;
         if (pair["Value"] === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [pair["Name"]]: __expectString(pair["Value"]),
-        };
+        return __assign(__assign({}, acc), (_a = {}, _a[pair["Name"]] = __expectString(pair["Value"]), _a));
     }, {});
 };
-const deserializeAws_queryOverLimit = (output, context) => {
-    const contents = {};
+var deserializeAws_queryOverLimit = function (output, context) {
+    var contents = {};
     return contents;
 };
-const deserializeAws_queryPurgeQueueInProgress = (output, context) => {
-    const contents = {};
+var deserializeAws_queryPurgeQueueInProgress = function (output, context) {
+    var contents = {};
     return contents;
 };
-const deserializeAws_queryQueueAttributeMap = (output, context) => {
-    return output.reduce((acc, pair) => {
+var deserializeAws_queryQueueAttributeMap = function (output, context) {
+    return output.reduce(function (acc, pair) {
+        var _a;
         if (pair["Value"] === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [pair["Name"]]: __expectString(pair["Value"]),
-        };
+        return __assign(__assign({}, acc), (_a = {}, _a[pair["Name"]] = __expectString(pair["Value"]), _a));
     }, {});
 };
-const deserializeAws_queryQueueDeletedRecently = (output, context) => {
-    const contents = {};
+var deserializeAws_queryQueueDeletedRecently = function (output, context) {
+    var contents = {};
     return contents;
 };
-const deserializeAws_queryQueueDoesNotExist = (output, context) => {
-    const contents = {};
+var deserializeAws_queryQueueDoesNotExist = function (output, context) {
+    var contents = {};
     return contents;
 };
-const deserializeAws_queryQueueNameExists = (output, context) => {
-    const contents = {};
+var deserializeAws_queryQueueNameExists = function (output, context) {
+    var contents = {};
     return contents;
 };
-const deserializeAws_queryQueueUrlList = (output, context) => {
+var deserializeAws_queryQueueUrlList = function (output, context) {
     return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return __expectString(entry);
     });
 };
-const deserializeAws_queryReceiptHandleIsInvalid = (output, context) => {
-    const contents = {};
+var deserializeAws_queryReceiptHandleIsInvalid = function (output, context) {
+    var contents = {};
     return contents;
 };
-const deserializeAws_queryReceiveMessageResult = (output, context) => {
-    const contents = {
+var deserializeAws_queryReceiveMessageResult = function (output, context) {
+    var contents = {
         Messages: undefined,
     };
     if (output.Message === "") {
@@ -1989,8 +2459,8 @@ const deserializeAws_queryReceiveMessageResult = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_querySendMessageBatchResult = (output, context) => {
-    const contents = {
+var deserializeAws_querySendMessageBatchResult = function (output, context) {
+    var contents = {
         Successful: undefined,
         Failed: undefined,
     };
@@ -2008,8 +2478,8 @@ const deserializeAws_querySendMessageBatchResult = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_querySendMessageBatchResultEntry = (output, context) => {
-    const contents = {
+var deserializeAws_querySendMessageBatchResultEntry = function (output, context) {
+    var contents = {
         Id: undefined,
         MessageId: undefined,
         MD5OfMessageBody: undefined,
@@ -2037,15 +2507,15 @@ const deserializeAws_querySendMessageBatchResultEntry = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_querySendMessageBatchResultEntryList = (output, context) => {
+var deserializeAws_querySendMessageBatchResultEntryList = function (output, context) {
     return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return deserializeAws_querySendMessageBatchResultEntry(entry, context);
     });
 };
-const deserializeAws_querySendMessageResult = (output, context) => {
-    const contents = {
+var deserializeAws_querySendMessageResult = function (output, context) {
+    var contents = {
         MD5OfMessageBody: undefined,
         MD5OfMessageAttributes: undefined,
         MD5OfMessageSystemAttributes: undefined,
@@ -2069,94 +2539,120 @@ const deserializeAws_querySendMessageResult = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryStringList = (output, context) => {
+var deserializeAws_queryStringList = function (output, context) {
     return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return __expectString(entry);
     });
 };
-const deserializeAws_queryTagMap = (output, context) => {
-    return output.reduce((acc, pair) => {
+var deserializeAws_queryTagMap = function (output, context) {
+    return output.reduce(function (acc, pair) {
+        var _a;
         if (pair["Value"] === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [pair["Key"]]: __expectString(pair["Value"]),
-        };
+        return __assign(__assign({}, acc), (_a = {}, _a[pair["Key"]] = __expectString(pair["Value"]), _a));
     }, {});
 };
-const deserializeAws_queryTooManyEntriesInBatchRequest = (output, context) => {
-    const contents = {};
+var deserializeAws_queryTooManyEntriesInBatchRequest = function (output, context) {
+    var contents = {};
     return contents;
 };
-const deserializeAws_queryUnsupportedOperation = (output, context) => {
-    const contents = {};
+var deserializeAws_queryUnsupportedOperation = function (output, context) {
+    var contents = {};
     return contents;
 };
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
-const collectBody = (streamBody = new Uint8Array(), context) => {
+var deserializeMetadata = function (output) {
+    var _a, _b;
+    return ({
+        httpStatusCode: output.statusCode,
+        requestId: (_b = (_a = output.headers["x-amzn-requestid"]) !== null && _a !== void 0 ? _a : output.headers["x-amzn-request-id"]) !== null && _b !== void 0 ? _b : output.headers["x-amz-request-id"],
+        extendedRequestId: output.headers["x-amz-id-2"],
+        cfId: output.headers["x-amz-cf-id"],
+    });
+};
+var collectBody = function (streamBody, context) {
+    if (streamBody === void 0) { streamBody = new Uint8Array(); }
     if (streamBody instanceof Uint8Array) {
         return Promise.resolve(streamBody);
     }
     return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
 };
-const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
-const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const contents = {
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-        headers,
-    };
-    if (resolvedHostname !== undefined) {
-        contents.hostname = resolvedHostname;
-    }
-    if (body !== undefined) {
-        contents.body = body;
-    }
-    return new __HttpRequest(contents);
-};
-const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
-    if (encoded.length) {
-        const parsedObj = xmlParse(encoded, {
-            attributeNamePrefix: "",
-            ignoreAttributes: false,
-            parseNodeValue: false,
-            trimValues: false,
-            tagValueProcessor: (val) => (val.trim() === "" && val.includes("\n") ? "" : decodeHTML(val)),
-        });
-        const textNodeName = "#text";
-        const key = Object.keys(parsedObj)[0];
-        const parsedObjToReturn = parsedObj[key];
-        if (parsedObjToReturn[textNodeName]) {
-            parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
-            delete parsedObjToReturn[textNodeName];
-        }
-        return __getValueFromTextNode(parsedObjToReturn);
-    }
-    return {};
-});
-const parseErrorBody = async (errorBody, context) => {
-    const value = await parseBody(errorBody, context);
-    if (value.Error) {
-        value.Error.message = value.Error.message ?? value.Error.Message;
-    }
-    return value;
-};
-const buildFormUrlencodedString = (formEntries) => Object.entries(formEntries)
-    .map(([key, value]) => __extendedEncodeURIComponent(key) + "=" + __extendedEncodeURIComponent(value))
-    .join("&");
-const loadQueryErrorCode = (output, data) => {
+var collectBodyString = function (streamBody, context) {
+    return collectBody(streamBody, context).then(function (body) { return context.utf8Encoder(body); });
+};
+var buildHttpRpcRequest = function (context, headers, path, resolvedHostname, body) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, contents;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                contents = {
+                    protocol: protocol,
+                    hostname: hostname,
+                    port: port,
+                    method: "POST",
+                    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+                    headers: headers,
+                };
+                if (resolvedHostname !== undefined) {
+                    contents.hostname = resolvedHostname;
+                }
+                if (body !== undefined) {
+                    contents.body = body;
+                }
+                return [2, new __HttpRequest(contents)];
+        }
+    });
+}); };
+var parseBody = function (streamBody, context) {
+    return collectBodyString(streamBody, context).then(function (encoded) {
+        if (encoded.length) {
+            var parsedObj = xmlParse(encoded, {
+                attributeNamePrefix: "",
+                ignoreAttributes: false,
+                parseNodeValue: false,
+                trimValues: false,
+                tagValueProcessor: function (val) { return (val.trim() === "" && val.includes("\n") ? "" : decodeHTML(val)); },
+            });
+            var textNodeName = "#text";
+            var key = Object.keys(parsedObj)[0];
+            var parsedObjToReturn = parsedObj[key];
+            if (parsedObjToReturn[textNodeName]) {
+                parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
+                delete parsedObjToReturn[textNodeName];
+            }
+            return __getValueFromTextNode(parsedObjToReturn);
+        }
+        return {};
+    });
+};
+var parseErrorBody = function (errorBody, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var value;
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4, parseBody(errorBody, context)];
+            case 1:
+                value = _b.sent();
+                if (value.Error) {
+                    value.Error.message = (_a = value.Error.message) !== null && _a !== void 0 ? _a : value.Error.Message;
+                }
+                return [2, value];
+        }
+    });
+}); };
+var buildFormUrlencodedString = function (formEntries) {
+    return Object.entries(formEntries)
+        .map(function (_a) {
+        var _b = __read(_a, 2), key = _b[0], value = _b[1];
+        return __extendedEncodeURIComponent(key) + "=" + __extendedEncodeURIComponent(value);
+    })
+        .join("&");
+};
+var loadQueryErrorCode = function (output, data) {
     if (data.Error.Code !== undefined) {
         return data.Error.Code;
     }