@aws-sdk/client-sqs 3.186.0 → 3.188.0

package/dist-es/protocols/Aws_query.js

@@ -1,1403 +1,1051 @@
-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 { XMLParser } 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 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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-    });
-}); };
-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)];
-        }
+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",
     });
-}); };
-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];
-        }
+    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 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)];
-        }
+    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",
     });
-}); };
-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];
-        }
+    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",
     });
-}); };
-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)];
+    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",
     });
-}); };
-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)];
+    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",
     });
-}); };
-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)];
+    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",
     });
-}); };
-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)];
+    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",
     });
-}); };
-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)];
+    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",
     });
-}); };
-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)];
+    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",
     });
-}); };
-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)];
+    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",
     });
-}); };
-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)];
+    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",
     });
-}); };
-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)];
+    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",
     });
-}); };
-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)];
+    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",
     });
-}); };
-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)];
+    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",
     });
-}); };
-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)];
+    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",
     });
-}); };
-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)];
+    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",
     });
-}); };
-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)];
+    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",
     });
-}); };
-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)];
+    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",
     });
-}); };
-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)];
+    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",
     });
-}); };
-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++;
-        }
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const deserializeAws_queryAddPermissionCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_queryAddPermissionCommandError(output, context);
     }
-    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; }
+    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);
+    }
+    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++;
     }
     return entries;
 };
-var serializeAws_queryAddPermissionRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryAddPermissionRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
@@ -1405,109 +1053,73 @@ var serializeAws_queryAddPermissionRequest = function (input, context) {
         entries["Label"] = input.Label;
     }
     if (input.AWSAccountIds != null) {
-        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));
+        const memberEntries = serializeAws_queryAWSAccountIdList(input.AWSAccountIds, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `AWSAccountId.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     if (input.Actions != null) {
-        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));
+        const memberEntries = serializeAws_queryActionNameList(input.Actions, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `ActionName.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     return entries;
 };
-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++;
-        }
-    }
-    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);
+const serializeAws_queryAttributeNameList = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
         }
-        finally { if (e_2) throw e_2.error; }
+        entries[`member.${counter}`] = entry;
+        counter++;
     }
     return entries;
 };
-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++;
-        }
-    }
-    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);
+const serializeAws_queryAWSAccountIdList = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
         }
-        finally { if (e_3) throw e_3.error; }
+        entries[`member.${counter}`] = entry;
+        counter++;
     }
     return entries;
 };
-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++;
+const serializeAws_queryBinaryList = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
         }
-    }
-    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; }
+        entries[`BinaryListValue.${counter}`] = context.base64Encoder(entry);
+        counter++;
     }
     return entries;
 };
-var serializeAws_queryChangeMessageVisibilityBatchRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryChangeMessageVisibilityBatchRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.Entries != null) {
-        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));
+        const memberEntries = serializeAws_queryChangeMessageVisibilityBatchRequestEntryList(input.Entries, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `ChangeMessageVisibilityBatchRequestEntry.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     return entries;
 };
-var serializeAws_queryChangeMessageVisibilityBatchRequestEntry = function (input, context) {
-    var entries = {};
+const serializeAws_queryChangeMessageVisibilityBatchRequestEntry = (input, context) => {
+    const entries = {};
     if (input.Id != null) {
         entries["Id"] = input.Id;
     }
@@ -1519,35 +1131,23 @@ var serializeAws_queryChangeMessageVisibilityBatchRequestEntry = function (input
     }
     return entries;
 };
-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++;
-        }
-    }
-    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);
+const serializeAws_queryChangeMessageVisibilityBatchRequestEntryList = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
         }
-        finally { if (e_5) throw e_5.error; }
+        const memberEntries = serializeAws_queryChangeMessageVisibilityBatchRequestEntry(entry, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            entries[`member.${counter}.${key}`] = value;
+        });
+        counter++;
     }
     return entries;
 };
-var serializeAws_queryChangeMessageVisibilityRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryChangeMessageVisibilityRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
@@ -1559,46 +1159,43 @@ var serializeAws_queryChangeMessageVisibilityRequest = function (input, context)
     }
     return entries;
 };
-var serializeAws_queryCreateQueueRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryCreateQueueRequest = (input, context) => {
+    const entries = {};
     if (input.QueueName != null) {
         entries["QueueName"] = input.QueueName;
     }
     if (input.tags != null) {
-        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));
+        const memberEntries = serializeAws_queryTagMap(input.tags, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `Tag.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     if (input.Attributes != null) {
-        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));
+        const memberEntries = serializeAws_queryQueueAttributeMap(input.Attributes, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `Attribute.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     return entries;
 };
-var serializeAws_queryDeleteMessageBatchRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryDeleteMessageBatchRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.Entries != null) {
-        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));
+        const memberEntries = serializeAws_queryDeleteMessageBatchRequestEntryList(input.Entries, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `DeleteMessageBatchRequestEntry.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     return entries;
 };
-var serializeAws_queryDeleteMessageBatchRequestEntry = function (input, context) {
-    var entries = {};
+const serializeAws_queryDeleteMessageBatchRequestEntry = (input, context) => {
+    const entries = {};
     if (input.Id != null) {
         entries["Id"] = input.Id;
     }
@@ -1607,35 +1204,23 @@ var serializeAws_queryDeleteMessageBatchRequestEntry = function (input, context)
     }
     return entries;
 };
-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++;
-        }
-    }
-    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);
+const serializeAws_queryDeleteMessageBatchRequestEntryList = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
         }
-        finally { if (e_6) throw e_6.error; }
+        const memberEntries = serializeAws_queryDeleteMessageBatchRequestEntry(entry, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            entries[`member.${counter}.${key}`] = value;
+        });
+        counter++;
     }
     return entries;
 };
-var serializeAws_queryDeleteMessageRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryDeleteMessageRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
@@ -1644,30 +1229,29 @@ var serializeAws_queryDeleteMessageRequest = function (input, context) {
     }
     return entries;
 };
-var serializeAws_queryDeleteQueueRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryDeleteQueueRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     return entries;
 };
-var serializeAws_queryGetQueueAttributesRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryGetQueueAttributesRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.AttributeNames != null) {
-        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));
+        const memberEntries = serializeAws_queryAttributeNameList(input.AttributeNames, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `AttributeName.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     return entries;
 };
-var serializeAws_queryGetQueueUrlRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryGetQueueUrlRequest = (input, context) => {
+    const entries = {};
     if (input.QueueName != null) {
         entries["QueueName"] = input.QueueName;
     }
@@ -1676,8 +1260,8 @@ var serializeAws_queryGetQueueUrlRequest = function (input, context) {
     }
     return entries;
 };
-var serializeAws_queryListDeadLetterSourceQueuesRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryListDeadLetterSourceQueuesRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
@@ -1689,8 +1273,8 @@ var serializeAws_queryListDeadLetterSourceQueuesRequest = function (input, conte
     }
     return entries;
 };
-var serializeAws_queryListQueuesRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryListQueuesRequest = (input, context) => {
+    const entries = {};
     if (input.QueueNamePrefix != null) {
         entries["QueueNamePrefix"] = input.QueueNamePrefix;
     }
@@ -1702,38 +1286,27 @@ var serializeAws_queryListQueuesRequest = function (input, context) {
     }
     return entries;
 };
-var serializeAws_queryListQueueTagsRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryListQueueTagsRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     return entries;
 };
-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++;
+const serializeAws_queryMessageAttributeNameList = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
         }
-    }
-    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; }
+        entries[`member.${counter}`] = entry;
+        counter++;
     }
     return entries;
 };
-var serializeAws_queryMessageAttributeValue = function (input, context) {
-    var entries = {};
+const serializeAws_queryMessageAttributeValue = (input, context) => {
+    const entries = {};
     if (input.StringValue != null) {
         entries["StringValue"] = input.StringValue;
     }
@@ -1741,18 +1314,16 @@ var serializeAws_queryMessageAttributeValue = function (input, context) {
         entries["BinaryValue"] = context.base64Encoder(input.BinaryValue);
     }
     if (input.StringListValues != null) {
-        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));
+        const memberEntries = serializeAws_queryStringList(input.StringListValues, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `StringListValue.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     if (input.BinaryListValues != null) {
-        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));
+        const memberEntries = serializeAws_queryBinaryList(input.BinaryListValues, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `BinaryListValue.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
@@ -1761,40 +1332,38 @@ var serializeAws_queryMessageAttributeValue = function (input, context) {
     }
     return entries;
 };
-var serializeAws_queryMessageBodyAttributeMap = function (input, context) {
-    var entries = {};
-    var counter = 1;
+const serializeAws_queryMessageBodyAttributeMap = (input, context) => {
+    const entries = {};
+    let counter = 1;
     Object.keys(input)
-        .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;
+        .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;
         });
         counter++;
     });
     return entries;
 };
-var serializeAws_queryMessageBodySystemAttributeMap = function (input, context) {
-    var entries = {};
-    var counter = 1;
+const serializeAws_queryMessageBodySystemAttributeMap = (input, context) => {
+    const entries = {};
+    let counter = 1;
     Object.keys(input)
-        .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;
+        .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;
         });
         counter++;
     });
     return entries;
 };
-var serializeAws_queryMessageSystemAttributeValue = function (input, context) {
-    var entries = {};
+const serializeAws_queryMessageSystemAttributeValue = (input, context) => {
+    const entries = {};
     if (input.StringValue != null) {
         entries["StringValue"] = input.StringValue;
     }
@@ -1802,18 +1371,16 @@ var serializeAws_queryMessageSystemAttributeValue = function (input, context) {
         entries["BinaryValue"] = context.base64Encoder(input.BinaryValue);
     }
     if (input.StringListValues != null) {
-        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));
+        const memberEntries = serializeAws_queryStringList(input.StringListValues, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `StringListValue.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     if (input.BinaryListValues != null) {
-        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));
+        const memberEntries = serializeAws_queryBinaryList(input.BinaryListValues, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `BinaryListValue.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
@@ -1822,43 +1389,41 @@ var serializeAws_queryMessageSystemAttributeValue = function (input, context) {
     }
     return entries;
 };
-var serializeAws_queryPurgeQueueRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryPurgeQueueRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     return entries;
 };
-var serializeAws_queryQueueAttributeMap = function (input, context) {
-    var entries = {};
-    var counter = 1;
+const serializeAws_queryQueueAttributeMap = (input, context) => {
+    const entries = {};
+    let counter = 1;
     Object.keys(input)
-        .filter(function (key) { return input[key] != null; })
-        .forEach(function (key) {
-        entries["entry.".concat(counter, ".Name")] = key;
-        entries["entry.".concat(counter, ".Value")] = input[key];
+        .filter((key) => input[key] != null)
+        .forEach((key) => {
+        entries[`entry.${counter}.Name`] = key;
+        entries[`entry.${counter}.Value`] = input[key];
         counter++;
     });
     return entries;
 };
-var serializeAws_queryReceiveMessageRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryReceiveMessageRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.AttributeNames != null) {
-        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));
+        const memberEntries = serializeAws_queryAttributeNameList(input.AttributeNames, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `AttributeName.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     if (input.MessageAttributeNames != null) {
-        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));
+        const memberEntries = serializeAws_queryMessageAttributeNameList(input.MessageAttributeNames, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `MessageAttributeName.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
@@ -1876,8 +1441,8 @@ var serializeAws_queryReceiveMessageRequest = function (input, context) {
     }
     return entries;
 };
-var serializeAws_queryRemovePermissionRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryRemovePermissionRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
@@ -1886,23 +1451,22 @@ var serializeAws_queryRemovePermissionRequest = function (input, context) {
     }
     return entries;
 };
-var serializeAws_querySendMessageBatchRequest = function (input, context) {
-    var entries = {};
+const serializeAws_querySendMessageBatchRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.Entries != null) {
-        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));
+        const memberEntries = serializeAws_querySendMessageBatchRequestEntryList(input.Entries, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `SendMessageBatchRequestEntry.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     return entries;
 };
-var serializeAws_querySendMessageBatchRequestEntry = function (input, context) {
-    var entries = {};
+const serializeAws_querySendMessageBatchRequestEntry = (input, context) => {
+    const entries = {};
     if (input.Id != null) {
         entries["Id"] = input.Id;
     }
@@ -1913,18 +1477,16 @@ var serializeAws_querySendMessageBatchRequestEntry = function (input, context) {
         entries["DelaySeconds"] = input.DelaySeconds;
     }
     if (input.MessageAttributes != null) {
-        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));
+        const memberEntries = serializeAws_queryMessageBodyAttributeMap(input.MessageAttributes, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `MessageAttribute.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     if (input.MessageSystemAttributes != null) {
-        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));
+        const memberEntries = serializeAws_queryMessageBodySystemAttributeMap(input.MessageSystemAttributes, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `MessageSystemAttribute.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
@@ -1936,35 +1498,23 @@ var serializeAws_querySendMessageBatchRequestEntry = function (input, context) {
     }
     return entries;
 };
-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++;
-        }
-    }
-    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);
+const serializeAws_querySendMessageBatchRequestEntryList = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
         }
-        finally { if (e_8) throw e_8.error; }
+        const memberEntries = serializeAws_querySendMessageBatchRequestEntry(entry, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            entries[`member.${counter}.${key}`] = value;
+        });
+        counter++;
     }
     return entries;
 };
-var serializeAws_querySendMessageRequest = function (input, context) {
-    var entries = {};
+const serializeAws_querySendMessageRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
@@ -1975,18 +1525,16 @@ var serializeAws_querySendMessageRequest = function (input, context) {
         entries["DelaySeconds"] = input.DelaySeconds;
     }
     if (input.MessageAttributes != null) {
-        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));
+        const memberEntries = serializeAws_queryMessageBodyAttributeMap(input.MessageAttributes, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `MessageAttribute.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     if (input.MessageSystemAttributes != null) {
-        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));
+        const memberEntries = serializeAws_queryMessageBodySystemAttributeMap(input.MessageSystemAttributes, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `MessageSystemAttribute.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
@@ -1998,119 +1546,94 @@ var serializeAws_querySendMessageRequest = function (input, context) {
     }
     return entries;
 };
-var serializeAws_querySetQueueAttributesRequest = function (input, context) {
-    var entries = {};
+const serializeAws_querySetQueueAttributesRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.Attributes != null) {
-        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));
+        const memberEntries = serializeAws_queryQueueAttributeMap(input.Attributes, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `Attribute.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     return entries;
 };
-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++;
-        }
-    }
-    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);
+const serializeAws_queryStringList = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
         }
-        finally { if (e_9) throw e_9.error; }
+        entries[`StringListValue.${counter}`] = entry;
+        counter++;
     }
     return entries;
 };
-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++;
-        }
-    }
-    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);
+const serializeAws_queryTagKeyList = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
         }
-        finally { if (e_10) throw e_10.error; }
+        entries[`member.${counter}`] = entry;
+        counter++;
     }
     return entries;
 };
-var serializeAws_queryTagMap = function (input, context) {
-    var entries = {};
-    var counter = 1;
+const serializeAws_queryTagMap = (input, context) => {
+    const entries = {};
+    let counter = 1;
     Object.keys(input)
-        .filter(function (key) { return input[key] != null; })
-        .forEach(function (key) {
-        entries["entry.".concat(counter, ".Key")] = key;
-        entries["entry.".concat(counter, ".Value")] = input[key];
+        .filter((key) => input[key] != null)
+        .forEach((key) => {
+        entries[`entry.${counter}.Key`] = key;
+        entries[`entry.${counter}.Value`] = input[key];
         counter++;
     });
     return entries;
 };
-var serializeAws_queryTagQueueRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryTagQueueRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.Tags != null) {
-        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));
+        const memberEntries = serializeAws_queryTagMap(input.Tags, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `Tag.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     return entries;
 };
-var serializeAws_queryUntagQueueRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryUntagQueueRequest = (input, context) => {
+    const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.TagKeys != null) {
-        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));
+        const memberEntries = serializeAws_queryTagKeyList(input.TagKeys, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TagKey.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     return entries;
 };
-var deserializeAws_queryBatchEntryIdsNotDistinct = function (output, context) {
-    var contents = {};
+const deserializeAws_queryBatchEntryIdsNotDistinct = (output, context) => {
+    const contents = {};
     return contents;
 };
-var deserializeAws_queryBatchRequestTooLong = function (output, context) {
-    var contents = {};
+const deserializeAws_queryBatchRequestTooLong = (output, context) => {
+    const contents = {};
     return contents;
 };
-var deserializeAws_queryBatchResultErrorEntry = function (output, context) {
-    var contents = {
+const deserializeAws_queryBatchResultErrorEntry = (output, context) => {
+    const contents = {
         Id: undefined,
         SenderFault: undefined,
         Code: undefined,
@@ -2130,22 +1653,22 @@ var deserializeAws_queryBatchResultErrorEntry = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryBatchResultErrorEntryList = function (output, context) {
+const deserializeAws_queryBatchResultErrorEntryList = (output, context) => {
     return (output || [])
-        .filter(function (e) { return e != null; })
-        .map(function (entry) {
+        .filter((e) => e != null)
+        .map((entry) => {
         return deserializeAws_queryBatchResultErrorEntry(entry, context);
     });
 };
-var deserializeAws_queryBinaryList = function (output, context) {
+const deserializeAws_queryBinaryList = (output, context) => {
     return (output || [])
-        .filter(function (e) { return e != null; })
-        .map(function (entry) {
+        .filter((e) => e != null)
+        .map((entry) => {
         return context.base64Decoder(entry);
     });
 };
-var deserializeAws_queryChangeMessageVisibilityBatchResult = function (output, context) {
-    var contents = {
+const deserializeAws_queryChangeMessageVisibilityBatchResult = (output, context) => {
+    const contents = {
         Successful: undefined,
         Failed: undefined,
     };
@@ -2163,8 +1686,8 @@ var deserializeAws_queryChangeMessageVisibilityBatchResult = function (output, c
     }
     return contents;
 };
-var deserializeAws_queryChangeMessageVisibilityBatchResultEntry = function (output, context) {
-    var contents = {
+const deserializeAws_queryChangeMessageVisibilityBatchResultEntry = (output, context) => {
+    const contents = {
         Id: undefined,
     };
     if (output["Id"] !== undefined) {
@@ -2172,15 +1695,15 @@ var deserializeAws_queryChangeMessageVisibilityBatchResultEntry = function (outp
     }
     return contents;
 };
-var deserializeAws_queryChangeMessageVisibilityBatchResultEntryList = function (output, context) {
+const deserializeAws_queryChangeMessageVisibilityBatchResultEntryList = (output, context) => {
     return (output || [])
-        .filter(function (e) { return e != null; })
-        .map(function (entry) {
+        .filter((e) => e != null)
+        .map((entry) => {
         return deserializeAws_queryChangeMessageVisibilityBatchResultEntry(entry, context);
     });
 };
-var deserializeAws_queryCreateQueueResult = function (output, context) {
-    var contents = {
+const deserializeAws_queryCreateQueueResult = (output, context) => {
+    const contents = {
         QueueUrl: undefined,
     };
     if (output["QueueUrl"] !== undefined) {
@@ -2188,8 +1711,8 @@ var deserializeAws_queryCreateQueueResult = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryDeleteMessageBatchResult = function (output, context) {
-    var contents = {
+const deserializeAws_queryDeleteMessageBatchResult = (output, context) => {
+    const contents = {
         Successful: undefined,
         Failed: undefined,
     };
@@ -2207,8 +1730,8 @@ var deserializeAws_queryDeleteMessageBatchResult = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryDeleteMessageBatchResultEntry = function (output, context) {
-    var contents = {
+const deserializeAws_queryDeleteMessageBatchResultEntry = (output, context) => {
+    const contents = {
         Id: undefined,
     };
     if (output["Id"] !== undefined) {
@@ -2216,19 +1739,19 @@ var deserializeAws_queryDeleteMessageBatchResultEntry = function (output, contex
     }
     return contents;
 };
-var deserializeAws_queryDeleteMessageBatchResultEntryList = function (output, context) {
+const deserializeAws_queryDeleteMessageBatchResultEntryList = (output, context) => {
     return (output || [])
-        .filter(function (e) { return e != null; })
-        .map(function (entry) {
+        .filter((e) => e != null)
+        .map((entry) => {
         return deserializeAws_queryDeleteMessageBatchResultEntry(entry, context);
     });
 };
-var deserializeAws_queryEmptyBatchRequest = function (output, context) {
-    var contents = {};
+const deserializeAws_queryEmptyBatchRequest = (output, context) => {
+    const contents = {};
     return contents;
 };
-var deserializeAws_queryGetQueueAttributesResult = function (output, context) {
-    var contents = {
+const deserializeAws_queryGetQueueAttributesResult = (output, context) => {
+    const contents = {
         Attributes: undefined,
     };
     if (output.Attribute === "") {
@@ -2239,8 +1762,8 @@ var deserializeAws_queryGetQueueAttributesResult = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryGetQueueUrlResult = function (output, context) {
-    var contents = {
+const deserializeAws_queryGetQueueUrlResult = (output, context) => {
+    const contents = {
         QueueUrl: undefined,
     };
     if (output["QueueUrl"] !== undefined) {
@@ -2248,24 +1771,24 @@ var deserializeAws_queryGetQueueUrlResult = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryInvalidAttributeName = function (output, context) {
-    var contents = {};
+const deserializeAws_queryInvalidAttributeName = (output, context) => {
+    const contents = {};
     return contents;
 };
-var deserializeAws_queryInvalidBatchEntryId = function (output, context) {
-    var contents = {};
+const deserializeAws_queryInvalidBatchEntryId = (output, context) => {
+    const contents = {};
     return contents;
 };
-var deserializeAws_queryInvalidIdFormat = function (output, context) {
-    var contents = {};
+const deserializeAws_queryInvalidIdFormat = (output, context) => {
+    const contents = {};
     return contents;
 };
-var deserializeAws_queryInvalidMessageContents = function (output, context) {
-    var contents = {};
+const deserializeAws_queryInvalidMessageContents = (output, context) => {
+    const contents = {};
     return contents;
 };
-var deserializeAws_queryListDeadLetterSourceQueuesResult = function (output, context) {
-    var contents = {
+const deserializeAws_queryListDeadLetterSourceQueuesResult = (output, context) => {
+    const contents = {
         queueUrls: undefined,
         NextToken: undefined,
     };
@@ -2280,8 +1803,8 @@ var deserializeAws_queryListDeadLetterSourceQueuesResult = function (output, con
     }
     return contents;
 };
-var deserializeAws_queryListQueuesResult = function (output, context) {
-    var contents = {
+const deserializeAws_queryListQueuesResult = (output, context) => {
+    const contents = {
         NextToken: undefined,
         QueueUrls: undefined,
     };
@@ -2296,8 +1819,8 @@ var deserializeAws_queryListQueuesResult = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryListQueueTagsResult = function (output, context) {
-    var contents = {
+const deserializeAws_queryListQueueTagsResult = (output, context) => {
+    const contents = {
         Tags: undefined,
     };
     if (output.Tag === "") {
@@ -2308,8 +1831,8 @@ var deserializeAws_queryListQueueTagsResult = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryMessage = function (output, context) {
-    var contents = {
+const deserializeAws_queryMessage = (output, context) => {
+    const contents = {
         MessageId: undefined,
         ReceiptHandle: undefined,
         MD5OfBody: undefined,
@@ -2347,8 +1870,8 @@ var deserializeAws_queryMessage = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryMessageAttributeValue = function (output, context) {
-    var contents = {
+const deserializeAws_queryMessageAttributeValue = (output, context) => {
+    const contents = {
         StringValue: undefined,
         BinaryValue: undefined,
         StringListValues: undefined,
@@ -2378,77 +1901,83 @@ var deserializeAws_queryMessageAttributeValue = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryMessageBodyAttributeMap = function (output, context) {
-    return output.reduce(function (acc, pair) {
-        var _a;
+const deserializeAws_queryMessageBodyAttributeMap = (output, context) => {
+    return output.reduce((acc, pair) => {
         if (pair["Value"] === null) {
             return acc;
         }
-        return __assign(__assign({}, acc), (_a = {}, _a[pair["Name"]] = deserializeAws_queryMessageAttributeValue(pair["Value"], context), _a));
+        return {
+            ...acc,
+            [pair["Name"]]: deserializeAws_queryMessageAttributeValue(pair["Value"], context),
+        };
     }, {});
 };
-var deserializeAws_queryMessageList = function (output, context) {
+const deserializeAws_queryMessageList = (output, context) => {
     return (output || [])
-        .filter(function (e) { return e != null; })
-        .map(function (entry) {
+        .filter((e) => e != null)
+        .map((entry) => {
         return deserializeAws_queryMessage(entry, context);
     });
 };
-var deserializeAws_queryMessageNotInflight = function (output, context) {
-    var contents = {};
+const deserializeAws_queryMessageNotInflight = (output, context) => {
+    const contents = {};
     return contents;
 };
-var deserializeAws_queryMessageSystemAttributeMap = function (output, context) {
-    return output.reduce(function (acc, pair) {
-        var _a;
+const deserializeAws_queryMessageSystemAttributeMap = (output, context) => {
+    return output.reduce((acc, pair) => {
         if (pair["Value"] === null) {
             return acc;
         }
-        return __assign(__assign({}, acc), (_a = {}, _a[pair["Name"]] = __expectString(pair["Value"]), _a));
+        return {
+            ...acc,
+            [pair["Name"]]: __expectString(pair["Value"]),
+        };
     }, {});
 };
-var deserializeAws_queryOverLimit = function (output, context) {
-    var contents = {};
+const deserializeAws_queryOverLimit = (output, context) => {
+    const contents = {};
     return contents;
 };
-var deserializeAws_queryPurgeQueueInProgress = function (output, context) {
-    var contents = {};
+const deserializeAws_queryPurgeQueueInProgress = (output, context) => {
+    const contents = {};
     return contents;
 };
-var deserializeAws_queryQueueAttributeMap = function (output, context) {
-    return output.reduce(function (acc, pair) {
-        var _a;
+const deserializeAws_queryQueueAttributeMap = (output, context) => {
+    return output.reduce((acc, pair) => {
         if (pair["Value"] === null) {
             return acc;
         }
-        return __assign(__assign({}, acc), (_a = {}, _a[pair["Name"]] = __expectString(pair["Value"]), _a));
+        return {
+            ...acc,
+            [pair["Name"]]: __expectString(pair["Value"]),
+        };
     }, {});
 };
-var deserializeAws_queryQueueDeletedRecently = function (output, context) {
-    var contents = {};
+const deserializeAws_queryQueueDeletedRecently = (output, context) => {
+    const contents = {};
     return contents;
 };
-var deserializeAws_queryQueueDoesNotExist = function (output, context) {
-    var contents = {};
+const deserializeAws_queryQueueDoesNotExist = (output, context) => {
+    const contents = {};
     return contents;
 };
-var deserializeAws_queryQueueNameExists = function (output, context) {
-    var contents = {};
+const deserializeAws_queryQueueNameExists = (output, context) => {
+    const contents = {};
     return contents;
 };
-var deserializeAws_queryQueueUrlList = function (output, context) {
+const deserializeAws_queryQueueUrlList = (output, context) => {
     return (output || [])
-        .filter(function (e) { return e != null; })
-        .map(function (entry) {
+        .filter((e) => e != null)
+        .map((entry) => {
         return __expectString(entry);
     });
 };
-var deserializeAws_queryReceiptHandleIsInvalid = function (output, context) {
-    var contents = {};
+const deserializeAws_queryReceiptHandleIsInvalid = (output, context) => {
+    const contents = {};
     return contents;
 };
-var deserializeAws_queryReceiveMessageResult = function (output, context) {
-    var contents = {
+const deserializeAws_queryReceiveMessageResult = (output, context) => {
+    const contents = {
         Messages: undefined,
     };
     if (output.Message === "") {
@@ -2459,8 +1988,8 @@ var deserializeAws_queryReceiveMessageResult = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_querySendMessageBatchResult = function (output, context) {
-    var contents = {
+const deserializeAws_querySendMessageBatchResult = (output, context) => {
+    const contents = {
         Successful: undefined,
         Failed: undefined,
     };
@@ -2478,8 +2007,8 @@ var deserializeAws_querySendMessageBatchResult = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_querySendMessageBatchResultEntry = function (output, context) {
-    var contents = {
+const deserializeAws_querySendMessageBatchResultEntry = (output, context) => {
+    const contents = {
         Id: undefined,
         MessageId: undefined,
         MD5OfMessageBody: undefined,
@@ -2507,15 +2036,15 @@ var deserializeAws_querySendMessageBatchResultEntry = function (output, context)
     }
     return contents;
 };
-var deserializeAws_querySendMessageBatchResultEntryList = function (output, context) {
+const deserializeAws_querySendMessageBatchResultEntryList = (output, context) => {
     return (output || [])
-        .filter(function (e) { return e != null; })
-        .map(function (entry) {
+        .filter((e) => e != null)
+        .map((entry) => {
         return deserializeAws_querySendMessageBatchResultEntry(entry, context);
     });
 };
-var deserializeAws_querySendMessageResult = function (output, context) {
-    var contents = {
+const deserializeAws_querySendMessageResult = (output, context) => {
+    const contents = {
         MD5OfMessageBody: undefined,
         MD5OfMessageAttributes: undefined,
         MD5OfMessageSystemAttributes: undefined,
@@ -2539,120 +2068,99 @@ var deserializeAws_querySendMessageResult = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryStringList = function (output, context) {
+const deserializeAws_queryStringList = (output, context) => {
     return (output || [])
-        .filter(function (e) { return e != null; })
-        .map(function (entry) {
+        .filter((e) => e != null)
+        .map((entry) => {
         return __expectString(entry);
     });
 };
-var deserializeAws_queryTagMap = function (output, context) {
-    return output.reduce(function (acc, pair) {
-        var _a;
+const deserializeAws_queryTagMap = (output, context) => {
+    return output.reduce((acc, pair) => {
         if (pair["Value"] === null) {
             return acc;
         }
-        return __assign(__assign({}, acc), (_a = {}, _a[pair["Key"]] = __expectString(pair["Value"]), _a));
+        return {
+            ...acc,
+            [pair["Key"]]: __expectString(pair["Value"]),
+        };
     }, {});
 };
-var deserializeAws_queryTooManyEntriesInBatchRequest = function (output, context) {
-    var contents = {};
+const deserializeAws_queryTooManyEntriesInBatchRequest = (output, context) => {
+    const contents = {};
     return contents;
 };
-var deserializeAws_queryUnsupportedOperation = function (output, context) {
-    var contents = {};
+const deserializeAws_queryUnsupportedOperation = (output, context) => {
+    const contents = {};
     return contents;
 };
-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(); }
+const deserializeMetadata = (output) => ({
+    httpStatusCode: output.statusCode,
+    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+    extendedRequestId: output.headers["x-amz-id-2"],
+    cfId: output.headers["x-amz-cf-id"],
+});
+const collectBody = (streamBody = new Uint8Array(), context) => {
     if (streamBody instanceof Uint8Array) {
         return Promise.resolve(streamBody);
     }
     return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
 };
-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) {
+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 parser = new XMLParser({
+            attributeNamePrefix: "",
+            htmlEntities: true,
+            ignoreAttributes: false,
+            ignoreDeclaration: true,
+            parseTagValue: false,
+            trimValues: false,
+            tagValueProcessor: (_, val) => (val.trim() === "" && val.includes("\n") ? "" : undefined),
+        });
+        parser.addEntity("#xD", "\r");
+        parser.addEntity("#10", "\n");
+        const parsedObj = parser.parse(encoded);
+        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) => {
     if (data.Error.Code !== undefined) {
         return data.Error.Code;
     }