@aws-sdk/client-sqs 3.306.0 → 3.309.0

package/dist-cjs/protocols/Aws_query.js

@@ -1,274 +1,274 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deserializeAws_queryUntagQueueCommand = exports.deserializeAws_queryTagQueueCommand = exports.deserializeAws_querySetQueueAttributesCommand = exports.deserializeAws_querySendMessageBatchCommand = exports.deserializeAws_querySendMessageCommand = exports.deserializeAws_queryRemovePermissionCommand = exports.deserializeAws_queryReceiveMessageCommand = exports.deserializeAws_queryPurgeQueueCommand = exports.deserializeAws_queryListQueueTagsCommand = exports.deserializeAws_queryListQueuesCommand = exports.deserializeAws_queryListDeadLetterSourceQueuesCommand = exports.deserializeAws_queryGetQueueUrlCommand = exports.deserializeAws_queryGetQueueAttributesCommand = exports.deserializeAws_queryDeleteQueueCommand = exports.deserializeAws_queryDeleteMessageBatchCommand = exports.deserializeAws_queryDeleteMessageCommand = exports.deserializeAws_queryCreateQueueCommand = exports.deserializeAws_queryChangeMessageVisibilityBatchCommand = exports.deserializeAws_queryChangeMessageVisibilityCommand = exports.deserializeAws_queryAddPermissionCommand = exports.serializeAws_queryUntagQueueCommand = exports.serializeAws_queryTagQueueCommand = exports.serializeAws_querySetQueueAttributesCommand = exports.serializeAws_querySendMessageBatchCommand = exports.serializeAws_querySendMessageCommand = exports.serializeAws_queryRemovePermissionCommand = exports.serializeAws_queryReceiveMessageCommand = exports.serializeAws_queryPurgeQueueCommand = exports.serializeAws_queryListQueueTagsCommand = exports.serializeAws_queryListQueuesCommand = exports.serializeAws_queryListDeadLetterSourceQueuesCommand = exports.serializeAws_queryGetQueueUrlCommand = exports.serializeAws_queryGetQueueAttributesCommand = exports.serializeAws_queryDeleteQueueCommand = exports.serializeAws_queryDeleteMessageBatchCommand = exports.serializeAws_queryDeleteMessageCommand = exports.serializeAws_queryCreateQueueCommand = exports.serializeAws_queryChangeMessageVisibilityBatchCommand = exports.serializeAws_queryChangeMessageVisibilityCommand = exports.serializeAws_queryAddPermissionCommand = void 0;
+exports.de_UntagQueueCommand = exports.de_TagQueueCommand = exports.de_SetQueueAttributesCommand = exports.de_SendMessageBatchCommand = exports.de_SendMessageCommand = exports.de_RemovePermissionCommand = exports.de_ReceiveMessageCommand = exports.de_PurgeQueueCommand = exports.de_ListQueueTagsCommand = exports.de_ListQueuesCommand = exports.de_ListDeadLetterSourceQueuesCommand = exports.de_GetQueueUrlCommand = exports.de_GetQueueAttributesCommand = exports.de_DeleteQueueCommand = exports.de_DeleteMessageBatchCommand = exports.de_DeleteMessageCommand = exports.de_CreateQueueCommand = exports.de_ChangeMessageVisibilityBatchCommand = exports.de_ChangeMessageVisibilityCommand = exports.de_AddPermissionCommand = exports.se_UntagQueueCommand = exports.se_TagQueueCommand = exports.se_SetQueueAttributesCommand = exports.se_SendMessageBatchCommand = exports.se_SendMessageCommand = exports.se_RemovePermissionCommand = exports.se_ReceiveMessageCommand = exports.se_PurgeQueueCommand = exports.se_ListQueueTagsCommand = exports.se_ListQueuesCommand = exports.se_ListDeadLetterSourceQueuesCommand = exports.se_GetQueueUrlCommand = exports.se_GetQueueAttributesCommand = exports.se_DeleteQueueCommand = exports.se_DeleteMessageBatchCommand = exports.se_DeleteMessageCommand = exports.se_CreateQueueCommand = exports.se_ChangeMessageVisibilityBatchCommand = exports.se_ChangeMessageVisibilityCommand = exports.se_AddPermissionCommand = void 0;
 const protocol_http_1 = require("@aws-sdk/protocol-http");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const fast_xml_parser_1 = require("fast-xml-parser");
 const models_0_1 = require("../models/models_0");
 const SQSServiceException_1 = require("../models/SQSServiceException");
-const serializeAws_queryAddPermissionCommand = async (input, context) => {
+const se_AddPermissionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryAddPermissionRequest(input, context),
+        ...se_AddPermissionRequest(input, context),
         Action: "AddPermission",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryAddPermissionCommand = serializeAws_queryAddPermissionCommand;
-const serializeAws_queryChangeMessageVisibilityCommand = async (input, context) => {
+exports.se_AddPermissionCommand = se_AddPermissionCommand;
+const se_ChangeMessageVisibilityCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryChangeMessageVisibilityRequest(input, context),
+        ...se_ChangeMessageVisibilityRequest(input, context),
         Action: "ChangeMessageVisibility",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryChangeMessageVisibilityCommand = serializeAws_queryChangeMessageVisibilityCommand;
-const serializeAws_queryChangeMessageVisibilityBatchCommand = async (input, context) => {
+exports.se_ChangeMessageVisibilityCommand = se_ChangeMessageVisibilityCommand;
+const se_ChangeMessageVisibilityBatchCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryChangeMessageVisibilityBatchRequest(input, context),
+        ...se_ChangeMessageVisibilityBatchRequest(input, context),
         Action: "ChangeMessageVisibilityBatch",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryChangeMessageVisibilityBatchCommand = serializeAws_queryChangeMessageVisibilityBatchCommand;
-const serializeAws_queryCreateQueueCommand = async (input, context) => {
+exports.se_ChangeMessageVisibilityBatchCommand = se_ChangeMessageVisibilityBatchCommand;
+const se_CreateQueueCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryCreateQueueRequest(input, context),
+        ...se_CreateQueueRequest(input, context),
         Action: "CreateQueue",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryCreateQueueCommand = serializeAws_queryCreateQueueCommand;
-const serializeAws_queryDeleteMessageCommand = async (input, context) => {
+exports.se_CreateQueueCommand = se_CreateQueueCommand;
+const se_DeleteMessageCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteMessageRequest(input, context),
+        ...se_DeleteMessageRequest(input, context),
         Action: "DeleteMessage",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryDeleteMessageCommand = serializeAws_queryDeleteMessageCommand;
-const serializeAws_queryDeleteMessageBatchCommand = async (input, context) => {
+exports.se_DeleteMessageCommand = se_DeleteMessageCommand;
+const se_DeleteMessageBatchCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteMessageBatchRequest(input, context),
+        ...se_DeleteMessageBatchRequest(input, context),
         Action: "DeleteMessageBatch",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryDeleteMessageBatchCommand = serializeAws_queryDeleteMessageBatchCommand;
-const serializeAws_queryDeleteQueueCommand = async (input, context) => {
+exports.se_DeleteMessageBatchCommand = se_DeleteMessageBatchCommand;
+const se_DeleteQueueCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteQueueRequest(input, context),
+        ...se_DeleteQueueRequest(input, context),
         Action: "DeleteQueue",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryDeleteQueueCommand = serializeAws_queryDeleteQueueCommand;
-const serializeAws_queryGetQueueAttributesCommand = async (input, context) => {
+exports.se_DeleteQueueCommand = se_DeleteQueueCommand;
+const se_GetQueueAttributesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryGetQueueAttributesRequest(input, context),
+        ...se_GetQueueAttributesRequest(input, context),
         Action: "GetQueueAttributes",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryGetQueueAttributesCommand = serializeAws_queryGetQueueAttributesCommand;
-const serializeAws_queryGetQueueUrlCommand = async (input, context) => {
+exports.se_GetQueueAttributesCommand = se_GetQueueAttributesCommand;
+const se_GetQueueUrlCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryGetQueueUrlRequest(input, context),
+        ...se_GetQueueUrlRequest(input, context),
         Action: "GetQueueUrl",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryGetQueueUrlCommand = serializeAws_queryGetQueueUrlCommand;
-const serializeAws_queryListDeadLetterSourceQueuesCommand = async (input, context) => {
+exports.se_GetQueueUrlCommand = se_GetQueueUrlCommand;
+const se_ListDeadLetterSourceQueuesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryListDeadLetterSourceQueuesRequest(input, context),
+        ...se_ListDeadLetterSourceQueuesRequest(input, context),
         Action: "ListDeadLetterSourceQueues",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryListDeadLetterSourceQueuesCommand = serializeAws_queryListDeadLetterSourceQueuesCommand;
-const serializeAws_queryListQueuesCommand = async (input, context) => {
+exports.se_ListDeadLetterSourceQueuesCommand = se_ListDeadLetterSourceQueuesCommand;
+const se_ListQueuesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryListQueuesRequest(input, context),
+        ...se_ListQueuesRequest(input, context),
         Action: "ListQueues",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryListQueuesCommand = serializeAws_queryListQueuesCommand;
-const serializeAws_queryListQueueTagsCommand = async (input, context) => {
+exports.se_ListQueuesCommand = se_ListQueuesCommand;
+const se_ListQueueTagsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryListQueueTagsRequest(input, context),
+        ...se_ListQueueTagsRequest(input, context),
         Action: "ListQueueTags",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryListQueueTagsCommand = serializeAws_queryListQueueTagsCommand;
-const serializeAws_queryPurgeQueueCommand = async (input, context) => {
+exports.se_ListQueueTagsCommand = se_ListQueueTagsCommand;
+const se_PurgeQueueCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryPurgeQueueRequest(input, context),
+        ...se_PurgeQueueRequest(input, context),
         Action: "PurgeQueue",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryPurgeQueueCommand = serializeAws_queryPurgeQueueCommand;
-const serializeAws_queryReceiveMessageCommand = async (input, context) => {
+exports.se_PurgeQueueCommand = se_PurgeQueueCommand;
+const se_ReceiveMessageCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryReceiveMessageRequest(input, context),
+        ...se_ReceiveMessageRequest(input, context),
         Action: "ReceiveMessage",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryReceiveMessageCommand = serializeAws_queryReceiveMessageCommand;
-const serializeAws_queryRemovePermissionCommand = async (input, context) => {
+exports.se_ReceiveMessageCommand = se_ReceiveMessageCommand;
+const se_RemovePermissionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryRemovePermissionRequest(input, context),
+        ...se_RemovePermissionRequest(input, context),
         Action: "RemovePermission",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryRemovePermissionCommand = serializeAws_queryRemovePermissionCommand;
-const serializeAws_querySendMessageCommand = async (input, context) => {
+exports.se_RemovePermissionCommand = se_RemovePermissionCommand;
+const se_SendMessageCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_querySendMessageRequest(input, context),
+        ...se_SendMessageRequest(input, context),
         Action: "SendMessage",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_querySendMessageCommand = serializeAws_querySendMessageCommand;
-const serializeAws_querySendMessageBatchCommand = async (input, context) => {
+exports.se_SendMessageCommand = se_SendMessageCommand;
+const se_SendMessageBatchCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_querySendMessageBatchRequest(input, context),
+        ...se_SendMessageBatchRequest(input, context),
         Action: "SendMessageBatch",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_querySendMessageBatchCommand = serializeAws_querySendMessageBatchCommand;
-const serializeAws_querySetQueueAttributesCommand = async (input, context) => {
+exports.se_SendMessageBatchCommand = se_SendMessageBatchCommand;
+const se_SetQueueAttributesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_querySetQueueAttributesRequest(input, context),
+        ...se_SetQueueAttributesRequest(input, context),
         Action: "SetQueueAttributes",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_querySetQueueAttributesCommand = serializeAws_querySetQueueAttributesCommand;
-const serializeAws_queryTagQueueCommand = async (input, context) => {
+exports.se_SetQueueAttributesCommand = se_SetQueueAttributesCommand;
+const se_TagQueueCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryTagQueueRequest(input, context),
+        ...se_TagQueueRequest(input, context),
         Action: "TagQueue",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryTagQueueCommand = serializeAws_queryTagQueueCommand;
-const serializeAws_queryUntagQueueCommand = async (input, context) => {
+exports.se_TagQueueCommand = se_TagQueueCommand;
+const se_UntagQueueCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryUntagQueueRequest(input, context),
+        ...se_UntagQueueRequest(input, context),
         Action: "UntagQueue",
         Version: "2012-11-05",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-exports.serializeAws_queryUntagQueueCommand = serializeAws_queryUntagQueueCommand;
-const deserializeAws_queryAddPermissionCommand = async (output, context) => {
+exports.se_UntagQueueCommand = se_UntagQueueCommand;
+const de_AddPermissionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryAddPermissionCommandError(output, context);
+        return de_AddPermissionCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -276,8 +276,8 @@ const deserializeAws_queryAddPermissionCommand = async (output, context) => {
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryAddPermissionCommand = deserializeAws_queryAddPermissionCommand;
-const deserializeAws_queryAddPermissionCommandError = async (output, context) => {
+exports.de_AddPermissionCommand = de_AddPermissionCommand;
+const de_AddPermissionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -286,7 +286,7 @@ const deserializeAws_queryAddPermissionCommandError = async (output, context) =>
     switch (errorCode) {
         case "OverLimit":
         case "com.amazonaws.sqs#OverLimit":
-            throw await deserializeAws_queryOverLimitResponse(parsedOutput, context);
+            throw await de_OverLimitRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -297,9 +297,9 @@ const deserializeAws_queryAddPermissionCommandError = async (output, context) =>
             });
     }
 };
-const deserializeAws_queryChangeMessageVisibilityCommand = async (output, context) => {
+const de_ChangeMessageVisibilityCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryChangeMessageVisibilityCommandError(output, context);
+        return de_ChangeMessageVisibilityCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -307,8 +307,8 @@ const deserializeAws_queryChangeMessageVisibilityCommand = async (output, contex
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryChangeMessageVisibilityCommand = deserializeAws_queryChangeMessageVisibilityCommand;
-const deserializeAws_queryChangeMessageVisibilityCommandError = async (output, context) => {
+exports.de_ChangeMessageVisibilityCommand = de_ChangeMessageVisibilityCommand;
+const de_ChangeMessageVisibilityCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -317,10 +317,10 @@ const deserializeAws_queryChangeMessageVisibilityCommandError = async (output, c
     switch (errorCode) {
         case "AWS.SimpleQueueService.MessageNotInflight":
         case "com.amazonaws.sqs#MessageNotInflight":
-            throw await deserializeAws_queryMessageNotInflightResponse(parsedOutput, context);
+            throw await de_MessageNotInflightRes(parsedOutput, context);
         case "ReceiptHandleIsInvalid":
         case "com.amazonaws.sqs#ReceiptHandleIsInvalid":
-            throw await deserializeAws_queryReceiptHandleIsInvalidResponse(parsedOutput, context);
+            throw await de_ReceiptHandleIsInvalidRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -331,21 +331,21 @@ const deserializeAws_queryChangeMessageVisibilityCommandError = async (output, c
             });
     }
 };
-const deserializeAws_queryChangeMessageVisibilityBatchCommand = async (output, context) => {
+const de_ChangeMessageVisibilityBatchCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryChangeMessageVisibilityBatchCommandError(output, context);
+        return de_ChangeMessageVisibilityBatchCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryChangeMessageVisibilityBatchResult(data.ChangeMessageVisibilityBatchResult, context);
+    contents = de_ChangeMessageVisibilityBatchResult(data.ChangeMessageVisibilityBatchResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryChangeMessageVisibilityBatchCommand = deserializeAws_queryChangeMessageVisibilityBatchCommand;
-const deserializeAws_queryChangeMessageVisibilityBatchCommandError = async (output, context) => {
+exports.de_ChangeMessageVisibilityBatchCommand = de_ChangeMessageVisibilityBatchCommand;
+const de_ChangeMessageVisibilityBatchCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -354,16 +354,16 @@ const deserializeAws_queryChangeMessageVisibilityBatchCommandError = async (outp
     switch (errorCode) {
         case "AWS.SimpleQueueService.BatchEntryIdsNotDistinct":
         case "com.amazonaws.sqs#BatchEntryIdsNotDistinct":
-            throw await deserializeAws_queryBatchEntryIdsNotDistinctResponse(parsedOutput, context);
+            throw await de_BatchEntryIdsNotDistinctRes(parsedOutput, context);
         case "AWS.SimpleQueueService.EmptyBatchRequest":
         case "com.amazonaws.sqs#EmptyBatchRequest":
-            throw await deserializeAws_queryEmptyBatchRequestResponse(parsedOutput, context);
+            throw await de_EmptyBatchRequestRes(parsedOutput, context);
         case "AWS.SimpleQueueService.InvalidBatchEntryId":
         case "com.amazonaws.sqs#InvalidBatchEntryId":
-            throw await deserializeAws_queryInvalidBatchEntryIdResponse(parsedOutput, context);
+            throw await de_InvalidBatchEntryIdRes(parsedOutput, context);
         case "AWS.SimpleQueueService.TooManyEntriesInBatchRequest":
         case "com.amazonaws.sqs#TooManyEntriesInBatchRequest":
-            throw await deserializeAws_queryTooManyEntriesInBatchRequestResponse(parsedOutput, context);
+            throw await de_TooManyEntriesInBatchRequestRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -374,21 +374,21 @@ const deserializeAws_queryChangeMessageVisibilityBatchCommandError = async (outp
             });
     }
 };
-const deserializeAws_queryCreateQueueCommand = async (output, context) => {
+const de_CreateQueueCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryCreateQueueCommandError(output, context);
+        return de_CreateQueueCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryCreateQueueResult(data.CreateQueueResult, context);
+    contents = de_CreateQueueResult(data.CreateQueueResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryCreateQueueCommand = deserializeAws_queryCreateQueueCommand;
-const deserializeAws_queryCreateQueueCommandError = async (output, context) => {
+exports.de_CreateQueueCommand = de_CreateQueueCommand;
+const de_CreateQueueCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -397,10 +397,10 @@ const deserializeAws_queryCreateQueueCommandError = async (output, context) => {
     switch (errorCode) {
         case "AWS.SimpleQueueService.QueueDeletedRecently":
         case "com.amazonaws.sqs#QueueDeletedRecently":
-            throw await deserializeAws_queryQueueDeletedRecentlyResponse(parsedOutput, context);
+            throw await de_QueueDeletedRecentlyRes(parsedOutput, context);
         case "QueueAlreadyExists":
         case "com.amazonaws.sqs#QueueNameExists":
-            throw await deserializeAws_queryQueueNameExistsResponse(parsedOutput, context);
+            throw await de_QueueNameExistsRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -411,9 +411,9 @@ const deserializeAws_queryCreateQueueCommandError = async (output, context) => {
             });
     }
 };
-const deserializeAws_queryDeleteMessageCommand = async (output, context) => {
+const de_DeleteMessageCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteMessageCommandError(output, context);
+        return de_DeleteMessageCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -421,8 +421,8 @@ const deserializeAws_queryDeleteMessageCommand = async (output, context) => {
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryDeleteMessageCommand = deserializeAws_queryDeleteMessageCommand;
-const deserializeAws_queryDeleteMessageCommandError = async (output, context) => {
+exports.de_DeleteMessageCommand = de_DeleteMessageCommand;
+const de_DeleteMessageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -431,10 +431,10 @@ const deserializeAws_queryDeleteMessageCommandError = async (output, context) =>
     switch (errorCode) {
         case "InvalidIdFormat":
         case "com.amazonaws.sqs#InvalidIdFormat":
-            throw await deserializeAws_queryInvalidIdFormatResponse(parsedOutput, context);
+            throw await de_InvalidIdFormatRes(parsedOutput, context);
         case "ReceiptHandleIsInvalid":
         case "com.amazonaws.sqs#ReceiptHandleIsInvalid":
-            throw await deserializeAws_queryReceiptHandleIsInvalidResponse(parsedOutput, context);
+            throw await de_ReceiptHandleIsInvalidRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -445,21 +445,21 @@ const deserializeAws_queryDeleteMessageCommandError = async (output, context) =>
             });
     }
 };
-const deserializeAws_queryDeleteMessageBatchCommand = async (output, context) => {
+const de_DeleteMessageBatchCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteMessageBatchCommandError(output, context);
+        return de_DeleteMessageBatchCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDeleteMessageBatchResult(data.DeleteMessageBatchResult, context);
+    contents = de_DeleteMessageBatchResult(data.DeleteMessageBatchResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryDeleteMessageBatchCommand = deserializeAws_queryDeleteMessageBatchCommand;
-const deserializeAws_queryDeleteMessageBatchCommandError = async (output, context) => {
+exports.de_DeleteMessageBatchCommand = de_DeleteMessageBatchCommand;
+const de_DeleteMessageBatchCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -468,16 +468,16 @@ const deserializeAws_queryDeleteMessageBatchCommandError = async (output, contex
     switch (errorCode) {
         case "AWS.SimpleQueueService.BatchEntryIdsNotDistinct":
         case "com.amazonaws.sqs#BatchEntryIdsNotDistinct":
-            throw await deserializeAws_queryBatchEntryIdsNotDistinctResponse(parsedOutput, context);
+            throw await de_BatchEntryIdsNotDistinctRes(parsedOutput, context);
         case "AWS.SimpleQueueService.EmptyBatchRequest":
         case "com.amazonaws.sqs#EmptyBatchRequest":
-            throw await deserializeAws_queryEmptyBatchRequestResponse(parsedOutput, context);
+            throw await de_EmptyBatchRequestRes(parsedOutput, context);
         case "AWS.SimpleQueueService.InvalidBatchEntryId":
         case "com.amazonaws.sqs#InvalidBatchEntryId":
-            throw await deserializeAws_queryInvalidBatchEntryIdResponse(parsedOutput, context);
+            throw await de_InvalidBatchEntryIdRes(parsedOutput, context);
         case "AWS.SimpleQueueService.TooManyEntriesInBatchRequest":
         case "com.amazonaws.sqs#TooManyEntriesInBatchRequest":
-            throw await deserializeAws_queryTooManyEntriesInBatchRequestResponse(parsedOutput, context);
+            throw await de_TooManyEntriesInBatchRequestRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -488,9 +488,9 @@ const deserializeAws_queryDeleteMessageBatchCommandError = async (output, contex
             });
     }
 };
-const deserializeAws_queryDeleteQueueCommand = async (output, context) => {
+const de_DeleteQueueCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteQueueCommandError(output, context);
+        return de_DeleteQueueCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -498,8 +498,8 @@ const deserializeAws_queryDeleteQueueCommand = async (output, context) => {
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryDeleteQueueCommand = deserializeAws_queryDeleteQueueCommand;
-const deserializeAws_queryDeleteQueueCommandError = async (output, context) => {
+exports.de_DeleteQueueCommand = de_DeleteQueueCommand;
+const de_DeleteQueueCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -513,21 +513,21 @@ const deserializeAws_queryDeleteQueueCommandError = async (output, context) => {
         errorCode,
     });
 };
-const deserializeAws_queryGetQueueAttributesCommand = async (output, context) => {
+const de_GetQueueAttributesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryGetQueueAttributesCommandError(output, context);
+        return de_GetQueueAttributesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryGetQueueAttributesResult(data.GetQueueAttributesResult, context);
+    contents = de_GetQueueAttributesResult(data.GetQueueAttributesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryGetQueueAttributesCommand = deserializeAws_queryGetQueueAttributesCommand;
-const deserializeAws_queryGetQueueAttributesCommandError = async (output, context) => {
+exports.de_GetQueueAttributesCommand = de_GetQueueAttributesCommand;
+const de_GetQueueAttributesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -536,7 +536,7 @@ const deserializeAws_queryGetQueueAttributesCommandError = async (output, contex
     switch (errorCode) {
         case "InvalidAttributeName":
         case "com.amazonaws.sqs#InvalidAttributeName":
-            throw await deserializeAws_queryInvalidAttributeNameResponse(parsedOutput, context);
+            throw await de_InvalidAttributeNameRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -547,21 +547,21 @@ const deserializeAws_queryGetQueueAttributesCommandError = async (output, contex
             });
     }
 };
-const deserializeAws_queryGetQueueUrlCommand = async (output, context) => {
+const de_GetQueueUrlCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryGetQueueUrlCommandError(output, context);
+        return de_GetQueueUrlCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryGetQueueUrlResult(data.GetQueueUrlResult, context);
+    contents = de_GetQueueUrlResult(data.GetQueueUrlResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryGetQueueUrlCommand = deserializeAws_queryGetQueueUrlCommand;
-const deserializeAws_queryGetQueueUrlCommandError = async (output, context) => {
+exports.de_GetQueueUrlCommand = de_GetQueueUrlCommand;
+const de_GetQueueUrlCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -570,7 +570,7 @@ const deserializeAws_queryGetQueueUrlCommandError = async (output, context) => {
     switch (errorCode) {
         case "AWS.SimpleQueueService.NonExistentQueue":
         case "com.amazonaws.sqs#QueueDoesNotExist":
-            throw await deserializeAws_queryQueueDoesNotExistResponse(parsedOutput, context);
+            throw await de_QueueDoesNotExistRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -581,21 +581,21 @@ const deserializeAws_queryGetQueueUrlCommandError = async (output, context) => {
             });
     }
 };
-const deserializeAws_queryListDeadLetterSourceQueuesCommand = async (output, context) => {
+const de_ListDeadLetterSourceQueuesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryListDeadLetterSourceQueuesCommandError(output, context);
+        return de_ListDeadLetterSourceQueuesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryListDeadLetterSourceQueuesResult(data.ListDeadLetterSourceQueuesResult, context);
+    contents = de_ListDeadLetterSourceQueuesResult(data.ListDeadLetterSourceQueuesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryListDeadLetterSourceQueuesCommand = deserializeAws_queryListDeadLetterSourceQueuesCommand;
-const deserializeAws_queryListDeadLetterSourceQueuesCommandError = async (output, context) => {
+exports.de_ListDeadLetterSourceQueuesCommand = de_ListDeadLetterSourceQueuesCommand;
+const de_ListDeadLetterSourceQueuesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -604,7 +604,7 @@ const deserializeAws_queryListDeadLetterSourceQueuesCommandError = async (output
     switch (errorCode) {
         case "AWS.SimpleQueueService.NonExistentQueue":
         case "com.amazonaws.sqs#QueueDoesNotExist":
-            throw await deserializeAws_queryQueueDoesNotExistResponse(parsedOutput, context);
+            throw await de_QueueDoesNotExistRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -615,21 +615,21 @@ const deserializeAws_queryListDeadLetterSourceQueuesCommandError = async (output
             });
     }
 };
-const deserializeAws_queryListQueuesCommand = async (output, context) => {
+const de_ListQueuesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryListQueuesCommandError(output, context);
+        return de_ListQueuesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryListQueuesResult(data.ListQueuesResult, context);
+    contents = de_ListQueuesResult(data.ListQueuesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryListQueuesCommand = deserializeAws_queryListQueuesCommand;
-const deserializeAws_queryListQueuesCommandError = async (output, context) => {
+exports.de_ListQueuesCommand = de_ListQueuesCommand;
+const de_ListQueuesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -643,21 +643,21 @@ const deserializeAws_queryListQueuesCommandError = async (output, context) => {
         errorCode,
     });
 };
-const deserializeAws_queryListQueueTagsCommand = async (output, context) => {
+const de_ListQueueTagsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryListQueueTagsCommandError(output, context);
+        return de_ListQueueTagsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryListQueueTagsResult(data.ListQueueTagsResult, context);
+    contents = de_ListQueueTagsResult(data.ListQueueTagsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryListQueueTagsCommand = deserializeAws_queryListQueueTagsCommand;
-const deserializeAws_queryListQueueTagsCommandError = async (output, context) => {
+exports.de_ListQueueTagsCommand = de_ListQueueTagsCommand;
+const de_ListQueueTagsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -671,9 +671,9 @@ const deserializeAws_queryListQueueTagsCommandError = async (output, context) =>
         errorCode,
     });
 };
-const deserializeAws_queryPurgeQueueCommand = async (output, context) => {
+const de_PurgeQueueCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryPurgeQueueCommandError(output, context);
+        return de_PurgeQueueCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -681,8 +681,8 @@ const deserializeAws_queryPurgeQueueCommand = async (output, context) => {
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryPurgeQueueCommand = deserializeAws_queryPurgeQueueCommand;
-const deserializeAws_queryPurgeQueueCommandError = async (output, context) => {
+exports.de_PurgeQueueCommand = de_PurgeQueueCommand;
+const de_PurgeQueueCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -691,10 +691,10 @@ const deserializeAws_queryPurgeQueueCommandError = async (output, context) => {
     switch (errorCode) {
         case "AWS.SimpleQueueService.NonExistentQueue":
         case "com.amazonaws.sqs#QueueDoesNotExist":
-            throw await deserializeAws_queryQueueDoesNotExistResponse(parsedOutput, context);
+            throw await de_QueueDoesNotExistRes(parsedOutput, context);
         case "AWS.SimpleQueueService.PurgeQueueInProgress":
         case "com.amazonaws.sqs#PurgeQueueInProgress":
-            throw await deserializeAws_queryPurgeQueueInProgressResponse(parsedOutput, context);
+            throw await de_PurgeQueueInProgressRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -705,21 +705,21 @@ const deserializeAws_queryPurgeQueueCommandError = async (output, context) => {
             });
     }
 };
-const deserializeAws_queryReceiveMessageCommand = async (output, context) => {
+const de_ReceiveMessageCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryReceiveMessageCommandError(output, context);
+        return de_ReceiveMessageCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryReceiveMessageResult(data.ReceiveMessageResult, context);
+    contents = de_ReceiveMessageResult(data.ReceiveMessageResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryReceiveMessageCommand = deserializeAws_queryReceiveMessageCommand;
-const deserializeAws_queryReceiveMessageCommandError = async (output, context) => {
+exports.de_ReceiveMessageCommand = de_ReceiveMessageCommand;
+const de_ReceiveMessageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -728,7 +728,7 @@ const deserializeAws_queryReceiveMessageCommandError = async (output, context) =
     switch (errorCode) {
         case "OverLimit":
         case "com.amazonaws.sqs#OverLimit":
-            throw await deserializeAws_queryOverLimitResponse(parsedOutput, context);
+            throw await de_OverLimitRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -739,9 +739,9 @@ const deserializeAws_queryReceiveMessageCommandError = async (output, context) =
             });
     }
 };
-const deserializeAws_queryRemovePermissionCommand = async (output, context) => {
+const de_RemovePermissionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryRemovePermissionCommandError(output, context);
+        return de_RemovePermissionCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -749,8 +749,8 @@ const deserializeAws_queryRemovePermissionCommand = async (output, context) => {
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryRemovePermissionCommand = deserializeAws_queryRemovePermissionCommand;
-const deserializeAws_queryRemovePermissionCommandError = async (output, context) => {
+exports.de_RemovePermissionCommand = de_RemovePermissionCommand;
+const de_RemovePermissionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -764,21 +764,21 @@ const deserializeAws_queryRemovePermissionCommandError = async (output, context)
         errorCode,
     });
 };
-const deserializeAws_querySendMessageCommand = async (output, context) => {
+const de_SendMessageCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_querySendMessageCommandError(output, context);
+        return de_SendMessageCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_querySendMessageResult(data.SendMessageResult, context);
+    contents = de_SendMessageResult(data.SendMessageResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_querySendMessageCommand = deserializeAws_querySendMessageCommand;
-const deserializeAws_querySendMessageCommandError = async (output, context) => {
+exports.de_SendMessageCommand = de_SendMessageCommand;
+const de_SendMessageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -787,10 +787,10 @@ const deserializeAws_querySendMessageCommandError = async (output, context) => {
     switch (errorCode) {
         case "AWS.SimpleQueueService.UnsupportedOperation":
         case "com.amazonaws.sqs#UnsupportedOperation":
-            throw await deserializeAws_queryUnsupportedOperationResponse(parsedOutput, context);
+            throw await de_UnsupportedOperationRes(parsedOutput, context);
         case "InvalidMessageContents":
         case "com.amazonaws.sqs#InvalidMessageContents":
-            throw await deserializeAws_queryInvalidMessageContentsResponse(parsedOutput, context);
+            throw await de_InvalidMessageContentsRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -801,21 +801,21 @@ const deserializeAws_querySendMessageCommandError = async (output, context) => {
             });
     }
 };
-const deserializeAws_querySendMessageBatchCommand = async (output, context) => {
+const de_SendMessageBatchCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_querySendMessageBatchCommandError(output, context);
+        return de_SendMessageBatchCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_querySendMessageBatchResult(data.SendMessageBatchResult, context);
+    contents = de_SendMessageBatchResult(data.SendMessageBatchResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_querySendMessageBatchCommand = deserializeAws_querySendMessageBatchCommand;
-const deserializeAws_querySendMessageBatchCommandError = async (output, context) => {
+exports.de_SendMessageBatchCommand = de_SendMessageBatchCommand;
+const de_SendMessageBatchCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -824,22 +824,22 @@ const deserializeAws_querySendMessageBatchCommandError = async (output, context)
     switch (errorCode) {
         case "AWS.SimpleQueueService.BatchEntryIdsNotDistinct":
         case "com.amazonaws.sqs#BatchEntryIdsNotDistinct":
-            throw await deserializeAws_queryBatchEntryIdsNotDistinctResponse(parsedOutput, context);
+            throw await de_BatchEntryIdsNotDistinctRes(parsedOutput, context);
         case "AWS.SimpleQueueService.BatchRequestTooLong":
         case "com.amazonaws.sqs#BatchRequestTooLong":
-            throw await deserializeAws_queryBatchRequestTooLongResponse(parsedOutput, context);
+            throw await de_BatchRequestTooLongRes(parsedOutput, context);
         case "AWS.SimpleQueueService.EmptyBatchRequest":
         case "com.amazonaws.sqs#EmptyBatchRequest":
-            throw await deserializeAws_queryEmptyBatchRequestResponse(parsedOutput, context);
+            throw await de_EmptyBatchRequestRes(parsedOutput, context);
         case "AWS.SimpleQueueService.InvalidBatchEntryId":
         case "com.amazonaws.sqs#InvalidBatchEntryId":
-            throw await deserializeAws_queryInvalidBatchEntryIdResponse(parsedOutput, context);
+            throw await de_InvalidBatchEntryIdRes(parsedOutput, context);
         case "AWS.SimpleQueueService.TooManyEntriesInBatchRequest":
         case "com.amazonaws.sqs#TooManyEntriesInBatchRequest":
-            throw await deserializeAws_queryTooManyEntriesInBatchRequestResponse(parsedOutput, context);
+            throw await de_TooManyEntriesInBatchRequestRes(parsedOutput, context);
         case "AWS.SimpleQueueService.UnsupportedOperation":
         case "com.amazonaws.sqs#UnsupportedOperation":
-            throw await deserializeAws_queryUnsupportedOperationResponse(parsedOutput, context);
+            throw await de_UnsupportedOperationRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -850,9 +850,9 @@ const deserializeAws_querySendMessageBatchCommandError = async (output, context)
             });
     }
 };
-const deserializeAws_querySetQueueAttributesCommand = async (output, context) => {
+const de_SetQueueAttributesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_querySetQueueAttributesCommandError(output, context);
+        return de_SetQueueAttributesCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -860,8 +860,8 @@ const deserializeAws_querySetQueueAttributesCommand = async (output, context) =>
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_querySetQueueAttributesCommand = deserializeAws_querySetQueueAttributesCommand;
-const deserializeAws_querySetQueueAttributesCommandError = async (output, context) => {
+exports.de_SetQueueAttributesCommand = de_SetQueueAttributesCommand;
+const de_SetQueueAttributesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -870,7 +870,7 @@ const deserializeAws_querySetQueueAttributesCommandError = async (output, contex
     switch (errorCode) {
         case "InvalidAttributeName":
         case "com.amazonaws.sqs#InvalidAttributeName":
-            throw await deserializeAws_queryInvalidAttributeNameResponse(parsedOutput, context);
+            throw await de_InvalidAttributeNameRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -881,9 +881,9 @@ const deserializeAws_querySetQueueAttributesCommandError = async (output, contex
             });
     }
 };
-const deserializeAws_queryTagQueueCommand = async (output, context) => {
+const de_TagQueueCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryTagQueueCommandError(output, context);
+        return de_TagQueueCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -891,8 +891,8 @@ const deserializeAws_queryTagQueueCommand = async (output, context) => {
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryTagQueueCommand = deserializeAws_queryTagQueueCommand;
-const deserializeAws_queryTagQueueCommandError = async (output, context) => {
+exports.de_TagQueueCommand = de_TagQueueCommand;
+const de_TagQueueCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -906,9 +906,9 @@ const deserializeAws_queryTagQueueCommandError = async (output, context) => {
         errorCode,
     });
 };
-const deserializeAws_queryUntagQueueCommand = async (output, context) => {
+const de_UntagQueueCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryUntagQueueCommandError(output, context);
+        return de_UntagQueueCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -916,8 +916,8 @@ const deserializeAws_queryUntagQueueCommand = async (output, context) => {
     };
     return Promise.resolve(response);
 };
-exports.deserializeAws_queryUntagQueueCommand = deserializeAws_queryUntagQueueCommand;
-const deserializeAws_queryUntagQueueCommandError = async (output, context) => {
+exports.de_UntagQueueCommand = de_UntagQueueCommand;
+const de_UntagQueueCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -931,151 +931,151 @@ const deserializeAws_queryUntagQueueCommandError = async (output, context) => {
         errorCode,
     });
 };
-const deserializeAws_queryBatchEntryIdsNotDistinctResponse = async (parsedOutput, context) => {
+const de_BatchEntryIdsNotDistinctRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryBatchEntryIdsNotDistinct(body.Error, context);
+    const deserialized = de_BatchEntryIdsNotDistinct(body.Error, context);
     const exception = new models_0_1.BatchEntryIdsNotDistinct({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const deserializeAws_queryBatchRequestTooLongResponse = async (parsedOutput, context) => {
+const de_BatchRequestTooLongRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryBatchRequestTooLong(body.Error, context);
+    const deserialized = de_BatchRequestTooLong(body.Error, context);
     const exception = new models_0_1.BatchRequestTooLong({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const deserializeAws_queryEmptyBatchRequestResponse = async (parsedOutput, context) => {
+const de_EmptyBatchRequestRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryEmptyBatchRequest(body.Error, context);
+    const deserialized = de_EmptyBatchRequest(body.Error, context);
     const exception = new models_0_1.EmptyBatchRequest({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const deserializeAws_queryInvalidAttributeNameResponse = async (parsedOutput, context) => {
+const de_InvalidAttributeNameRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidAttributeName(body.Error, context);
+    const deserialized = de_InvalidAttributeName(body.Error, context);
     const exception = new models_0_1.InvalidAttributeName({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const deserializeAws_queryInvalidBatchEntryIdResponse = async (parsedOutput, context) => {
+const de_InvalidBatchEntryIdRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidBatchEntryId(body.Error, context);
+    const deserialized = de_InvalidBatchEntryId(body.Error, context);
     const exception = new models_0_1.InvalidBatchEntryId({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const deserializeAws_queryInvalidIdFormatResponse = async (parsedOutput, context) => {
+const de_InvalidIdFormatRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidIdFormat(body.Error, context);
+    const deserialized = de_InvalidIdFormat(body.Error, context);
     const exception = new models_0_1.InvalidIdFormat({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const deserializeAws_queryInvalidMessageContentsResponse = async (parsedOutput, context) => {
+const de_InvalidMessageContentsRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidMessageContents(body.Error, context);
+    const deserialized = de_InvalidMessageContents(body.Error, context);
     const exception = new models_0_1.InvalidMessageContents({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const deserializeAws_queryMessageNotInflightResponse = async (parsedOutput, context) => {
+const de_MessageNotInflightRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryMessageNotInflight(body.Error, context);
+    const deserialized = de_MessageNotInflight(body.Error, context);
     const exception = new models_0_1.MessageNotInflight({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const deserializeAws_queryOverLimitResponse = async (parsedOutput, context) => {
+const de_OverLimitRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryOverLimit(body.Error, context);
+    const deserialized = de_OverLimit(body.Error, context);
     const exception = new models_0_1.OverLimit({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const deserializeAws_queryPurgeQueueInProgressResponse = async (parsedOutput, context) => {
+const de_PurgeQueueInProgressRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryPurgeQueueInProgress(body.Error, context);
+    const deserialized = de_PurgeQueueInProgress(body.Error, context);
     const exception = new models_0_1.PurgeQueueInProgress({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const deserializeAws_queryQueueDeletedRecentlyResponse = async (parsedOutput, context) => {
+const de_QueueDeletedRecentlyRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryQueueDeletedRecently(body.Error, context);
+    const deserialized = de_QueueDeletedRecently(body.Error, context);
     const exception = new models_0_1.QueueDeletedRecently({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const deserializeAws_queryQueueDoesNotExistResponse = async (parsedOutput, context) => {
+const de_QueueDoesNotExistRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryQueueDoesNotExist(body.Error, context);
+    const deserialized = de_QueueDoesNotExist(body.Error, context);
     const exception = new models_0_1.QueueDoesNotExist({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const deserializeAws_queryQueueNameExistsResponse = async (parsedOutput, context) => {
+const de_QueueNameExistsRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryQueueNameExists(body.Error, context);
+    const deserialized = de_QueueNameExists(body.Error, context);
     const exception = new models_0_1.QueueNameExists({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const deserializeAws_queryReceiptHandleIsInvalidResponse = async (parsedOutput, context) => {
+const de_ReceiptHandleIsInvalidRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryReceiptHandleIsInvalid(body.Error, context);
+    const deserialized = de_ReceiptHandleIsInvalid(body.Error, context);
     const exception = new models_0_1.ReceiptHandleIsInvalid({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const deserializeAws_queryTooManyEntriesInBatchRequestResponse = async (parsedOutput, context) => {
+const de_TooManyEntriesInBatchRequestRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryTooManyEntriesInBatchRequest(body.Error, context);
+    const deserialized = de_TooManyEntriesInBatchRequest(body.Error, context);
     const exception = new models_0_1.TooManyEntriesInBatchRequest({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const deserializeAws_queryUnsupportedOperationResponse = async (parsedOutput, context) => {
+const de_UnsupportedOperationRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryUnsupportedOperation(body.Error, context);
+    const deserialized = de_UnsupportedOperation(body.Error, context);
     const exception = new models_0_1.UnsupportedOperation({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const serializeAws_queryActionNameList = (input, context) => {
+const se_ActionNameList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -1087,7 +1087,7 @@ const serializeAws_queryActionNameList = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryAddPermissionRequest = (input, context) => {
+const se_AddPermissionRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
@@ -1096,7 +1096,7 @@ const serializeAws_queryAddPermissionRequest = (input, context) => {
         entries["Label"] = input.Label;
     }
     if (input.AWSAccountIds != null) {
-        const memberEntries = serializeAws_queryAWSAccountIdList(input.AWSAccountIds, context);
+        const memberEntries = se_AWSAccountIdList(input.AWSAccountIds, context);
         if (input.AWSAccountIds?.length === 0) {
             entries.AWSAccountId = [];
         }
@@ -1106,7 +1106,7 @@ const serializeAws_queryAddPermissionRequest = (input, context) => {
         });
     }
     if (input.Actions != null) {
-        const memberEntries = serializeAws_queryActionNameList(input.Actions, context);
+        const memberEntries = se_ActionNameList(input.Actions, context);
         if (input.Actions?.length === 0) {
             entries.ActionName = [];
         }
@@ -1117,7 +1117,7 @@ const serializeAws_queryAddPermissionRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryAttributeNameList = (input, context) => {
+const se_AttributeNameList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -1129,7 +1129,7 @@ const serializeAws_queryAttributeNameList = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryAWSAccountIdList = (input, context) => {
+const se_AWSAccountIdList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -1141,7 +1141,7 @@ const serializeAws_queryAWSAccountIdList = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryBinaryList = (input, context) => {
+const se_BinaryList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -1153,13 +1153,13 @@ const serializeAws_queryBinaryList = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryChangeMessageVisibilityBatchRequest = (input, context) => {
+const se_ChangeMessageVisibilityBatchRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.Entries != null) {
-        const memberEntries = serializeAws_queryChangeMessageVisibilityBatchRequestEntryList(input.Entries, context);
+        const memberEntries = se_ChangeMessageVisibilityBatchRequestEntryList(input.Entries, context);
         if (input.Entries?.length === 0) {
             entries.ChangeMessageVisibilityBatchRequestEntry = [];
         }
@@ -1170,7 +1170,7 @@ const serializeAws_queryChangeMessageVisibilityBatchRequest = (input, context) =
     }
     return entries;
 };
-const serializeAws_queryChangeMessageVisibilityBatchRequestEntry = (input, context) => {
+const se_ChangeMessageVisibilityBatchRequestEntry = (input, context) => {
     const entries = {};
     if (input.Id != null) {
         entries["Id"] = input.Id;
@@ -1183,14 +1183,14 @@ const serializeAws_queryChangeMessageVisibilityBatchRequestEntry = (input, conte
     }
     return entries;
 };
-const serializeAws_queryChangeMessageVisibilityBatchRequestEntryList = (input, context) => {
+const se_ChangeMessageVisibilityBatchRequestEntryList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryChangeMessageVisibilityBatchRequestEntry(entry, context);
+        const memberEntries = se_ChangeMessageVisibilityBatchRequestEntry(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -1198,7 +1198,7 @@ const serializeAws_queryChangeMessageVisibilityBatchRequestEntryList = (input, c
     }
     return entries;
 };
-const serializeAws_queryChangeMessageVisibilityRequest = (input, context) => {
+const se_ChangeMessageVisibilityRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
@@ -1211,20 +1211,20 @@ const serializeAws_queryChangeMessageVisibilityRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryCreateQueueRequest = (input, context) => {
+const se_CreateQueueRequest = (input, context) => {
     const entries = {};
     if (input.QueueName != null) {
         entries["QueueName"] = input.QueueName;
     }
     if (input.tags != null) {
-        const memberEntries = serializeAws_queryTagMap(input.tags, context);
+        const memberEntries = se_TagMap(input.tags, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `Tag.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     if (input.Attributes != null) {
-        const memberEntries = serializeAws_queryQueueAttributeMap(input.Attributes, context);
+        const memberEntries = se_QueueAttributeMap(input.Attributes, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `Attribute.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
@@ -1232,13 +1232,13 @@ const serializeAws_queryCreateQueueRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeleteMessageBatchRequest = (input, context) => {
+const se_DeleteMessageBatchRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.Entries != null) {
-        const memberEntries = serializeAws_queryDeleteMessageBatchRequestEntryList(input.Entries, context);
+        const memberEntries = se_DeleteMessageBatchRequestEntryList(input.Entries, context);
         if (input.Entries?.length === 0) {
             entries.DeleteMessageBatchRequestEntry = [];
         }
@@ -1249,7 +1249,7 @@ const serializeAws_queryDeleteMessageBatchRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeleteMessageBatchRequestEntry = (input, context) => {
+const se_DeleteMessageBatchRequestEntry = (input, context) => {
     const entries = {};
     if (input.Id != null) {
         entries["Id"] = input.Id;
@@ -1259,14 +1259,14 @@ const serializeAws_queryDeleteMessageBatchRequestEntry = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeleteMessageBatchRequestEntryList = (input, context) => {
+const se_DeleteMessageBatchRequestEntryList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryDeleteMessageBatchRequestEntry(entry, context);
+        const memberEntries = se_DeleteMessageBatchRequestEntry(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -1274,7 +1274,7 @@ const serializeAws_queryDeleteMessageBatchRequestEntryList = (input, context) =>
     }
     return entries;
 };
-const serializeAws_queryDeleteMessageRequest = (input, context) => {
+const se_DeleteMessageRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
@@ -1284,20 +1284,20 @@ const serializeAws_queryDeleteMessageRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeleteQueueRequest = (input, context) => {
+const se_DeleteQueueRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     return entries;
 };
-const serializeAws_queryGetQueueAttributesRequest = (input, context) => {
+const se_GetQueueAttributesRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.AttributeNames != null) {
-        const memberEntries = serializeAws_queryAttributeNameList(input.AttributeNames, context);
+        const memberEntries = se_AttributeNameList(input.AttributeNames, context);
         if (input.AttributeNames?.length === 0) {
             entries.AttributeName = [];
         }
@@ -1308,7 +1308,7 @@ const serializeAws_queryGetQueueAttributesRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryGetQueueUrlRequest = (input, context) => {
+const se_GetQueueUrlRequest = (input, context) => {
     const entries = {};
     if (input.QueueName != null) {
         entries["QueueName"] = input.QueueName;
@@ -1318,7 +1318,7 @@ const serializeAws_queryGetQueueUrlRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryListDeadLetterSourceQueuesRequest = (input, context) => {
+const se_ListDeadLetterSourceQueuesRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
@@ -1331,7 +1331,7 @@ const serializeAws_queryListDeadLetterSourceQueuesRequest = (input, context) =>
     }
     return entries;
 };
-const serializeAws_queryListQueuesRequest = (input, context) => {
+const se_ListQueuesRequest = (input, context) => {
     const entries = {};
     if (input.QueueNamePrefix != null) {
         entries["QueueNamePrefix"] = input.QueueNamePrefix;
@@ -1344,14 +1344,14 @@ const serializeAws_queryListQueuesRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryListQueueTagsRequest = (input, context) => {
+const se_ListQueueTagsRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     return entries;
 };
-const serializeAws_queryMessageAttributeNameList = (input, context) => {
+const se_MessageAttributeNameList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -1363,7 +1363,7 @@ const serializeAws_queryMessageAttributeNameList = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryMessageAttributeValue = (input, context) => {
+const se_MessageAttributeValue = (input, context) => {
     const entries = {};
     if (input.StringValue != null) {
         entries["StringValue"] = input.StringValue;
@@ -1372,7 +1372,7 @@ const serializeAws_queryMessageAttributeValue = (input, context) => {
         entries["BinaryValue"] = context.base64Encoder(input.BinaryValue);
     }
     if (input.StringListValues != null) {
-        const memberEntries = serializeAws_queryStringList(input.StringListValues, context);
+        const memberEntries = se_StringList(input.StringListValues, context);
         if (input.StringListValues?.length === 0) {
             entries.StringListValue = [];
         }
@@ -1382,7 +1382,7 @@ const serializeAws_queryMessageAttributeValue = (input, context) => {
         });
     }
     if (input.BinaryListValues != null) {
-        const memberEntries = serializeAws_queryBinaryList(input.BinaryListValues, context);
+        const memberEntries = se_BinaryList(input.BinaryListValues, context);
         if (input.BinaryListValues?.length === 0) {
             entries.BinaryListValue = [];
         }
@@ -1396,14 +1396,14 @@ const serializeAws_queryMessageAttributeValue = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryMessageBodyAttributeMap = (input, context) => {
+const se_MessageBodyAttributeMap = (input, context) => {
     const entries = {};
     let counter = 1;
     Object.keys(input)
         .filter((key) => input[key] != null)
         .forEach((key) => {
         entries[`entry.${counter}.Name`] = key;
-        const memberEntries = serializeAws_queryMessageAttributeValue(input[key], context);
+        const memberEntries = se_MessageAttributeValue(input[key], context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`entry.${counter}.Value.${key}`] = value;
         });
@@ -1411,14 +1411,14 @@ const serializeAws_queryMessageBodyAttributeMap = (input, context) => {
     });
     return entries;
 };
-const serializeAws_queryMessageBodySystemAttributeMap = (input, context) => {
+const se_MessageBodySystemAttributeMap = (input, context) => {
     const entries = {};
     let counter = 1;
     Object.keys(input)
         .filter((key) => input[key] != null)
         .forEach((key) => {
         entries[`entry.${counter}.Name`] = key;
-        const memberEntries = serializeAws_queryMessageSystemAttributeValue(input[key], context);
+        const memberEntries = se_MessageSystemAttributeValue(input[key], context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`entry.${counter}.Value.${key}`] = value;
         });
@@ -1426,7 +1426,7 @@ const serializeAws_queryMessageBodySystemAttributeMap = (input, context) => {
     });
     return entries;
 };
-const serializeAws_queryMessageSystemAttributeValue = (input, context) => {
+const se_MessageSystemAttributeValue = (input, context) => {
     const entries = {};
     if (input.StringValue != null) {
         entries["StringValue"] = input.StringValue;
@@ -1435,7 +1435,7 @@ const serializeAws_queryMessageSystemAttributeValue = (input, context) => {
         entries["BinaryValue"] = context.base64Encoder(input.BinaryValue);
     }
     if (input.StringListValues != null) {
-        const memberEntries = serializeAws_queryStringList(input.StringListValues, context);
+        const memberEntries = se_StringList(input.StringListValues, context);
         if (input.StringListValues?.length === 0) {
             entries.StringListValue = [];
         }
@@ -1445,7 +1445,7 @@ const serializeAws_queryMessageSystemAttributeValue = (input, context) => {
         });
     }
     if (input.BinaryListValues != null) {
-        const memberEntries = serializeAws_queryBinaryList(input.BinaryListValues, context);
+        const memberEntries = se_BinaryList(input.BinaryListValues, context);
         if (input.BinaryListValues?.length === 0) {
             entries.BinaryListValue = [];
         }
@@ -1459,14 +1459,14 @@ const serializeAws_queryMessageSystemAttributeValue = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryPurgeQueueRequest = (input, context) => {
+const se_PurgeQueueRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     return entries;
 };
-const serializeAws_queryQueueAttributeMap = (input, context) => {
+const se_QueueAttributeMap = (input, context) => {
     const entries = {};
     let counter = 1;
     Object.keys(input)
@@ -1478,13 +1478,13 @@ const serializeAws_queryQueueAttributeMap = (input, context) => {
     });
     return entries;
 };
-const serializeAws_queryReceiveMessageRequest = (input, context) => {
+const se_ReceiveMessageRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.AttributeNames != null) {
-        const memberEntries = serializeAws_queryAttributeNameList(input.AttributeNames, context);
+        const memberEntries = se_AttributeNameList(input.AttributeNames, context);
         if (input.AttributeNames?.length === 0) {
             entries.AttributeName = [];
         }
@@ -1494,7 +1494,7 @@ const serializeAws_queryReceiveMessageRequest = (input, context) => {
         });
     }
     if (input.MessageAttributeNames != null) {
-        const memberEntries = serializeAws_queryMessageAttributeNameList(input.MessageAttributeNames, context);
+        const memberEntries = se_MessageAttributeNameList(input.MessageAttributeNames, context);
         if (input.MessageAttributeNames?.length === 0) {
             entries.MessageAttributeName = [];
         }
@@ -1517,7 +1517,7 @@ const serializeAws_queryReceiveMessageRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryRemovePermissionRequest = (input, context) => {
+const se_RemovePermissionRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
@@ -1527,13 +1527,13 @@ const serializeAws_queryRemovePermissionRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_querySendMessageBatchRequest = (input, context) => {
+const se_SendMessageBatchRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.Entries != null) {
-        const memberEntries = serializeAws_querySendMessageBatchRequestEntryList(input.Entries, context);
+        const memberEntries = se_SendMessageBatchRequestEntryList(input.Entries, context);
         if (input.Entries?.length === 0) {
             entries.SendMessageBatchRequestEntry = [];
         }
@@ -1544,7 +1544,7 @@ const serializeAws_querySendMessageBatchRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_querySendMessageBatchRequestEntry = (input, context) => {
+const se_SendMessageBatchRequestEntry = (input, context) => {
     const entries = {};
     if (input.Id != null) {
         entries["Id"] = input.Id;
@@ -1556,14 +1556,14 @@ const serializeAws_querySendMessageBatchRequestEntry = (input, context) => {
         entries["DelaySeconds"] = input.DelaySeconds;
     }
     if (input.MessageAttributes != null) {
-        const memberEntries = serializeAws_queryMessageBodyAttributeMap(input.MessageAttributes, context);
+        const memberEntries = se_MessageBodyAttributeMap(input.MessageAttributes, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `MessageAttribute.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     if (input.MessageSystemAttributes != null) {
-        const memberEntries = serializeAws_queryMessageBodySystemAttributeMap(input.MessageSystemAttributes, context);
+        const memberEntries = se_MessageBodySystemAttributeMap(input.MessageSystemAttributes, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `MessageSystemAttribute.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
@@ -1577,14 +1577,14 @@ const serializeAws_querySendMessageBatchRequestEntry = (input, context) => {
     }
     return entries;
 };
-const serializeAws_querySendMessageBatchRequestEntryList = (input, context) => {
+const se_SendMessageBatchRequestEntryList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_querySendMessageBatchRequestEntry(entry, context);
+        const memberEntries = se_SendMessageBatchRequestEntry(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -1592,7 +1592,7 @@ const serializeAws_querySendMessageBatchRequestEntryList = (input, context) => {
     }
     return entries;
 };
-const serializeAws_querySendMessageRequest = (input, context) => {
+const se_SendMessageRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
@@ -1604,14 +1604,14 @@ const serializeAws_querySendMessageRequest = (input, context) => {
         entries["DelaySeconds"] = input.DelaySeconds;
     }
     if (input.MessageAttributes != null) {
-        const memberEntries = serializeAws_queryMessageBodyAttributeMap(input.MessageAttributes, context);
+        const memberEntries = se_MessageBodyAttributeMap(input.MessageAttributes, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `MessageAttribute.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
     if (input.MessageSystemAttributes != null) {
-        const memberEntries = serializeAws_queryMessageBodySystemAttributeMap(input.MessageSystemAttributes, context);
+        const memberEntries = se_MessageBodySystemAttributeMap(input.MessageSystemAttributes, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `MessageSystemAttribute.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
@@ -1625,13 +1625,13 @@ const serializeAws_querySendMessageRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_querySetQueueAttributesRequest = (input, context) => {
+const se_SetQueueAttributesRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.Attributes != null) {
-        const memberEntries = serializeAws_queryQueueAttributeMap(input.Attributes, context);
+        const memberEntries = se_QueueAttributeMap(input.Attributes, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `Attribute.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
@@ -1639,7 +1639,7 @@ const serializeAws_querySetQueueAttributesRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryStringList = (input, context) => {
+const se_StringList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -1651,7 +1651,7 @@ const serializeAws_queryStringList = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryTagKeyList = (input, context) => {
+const se_TagKeyList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -1663,7 +1663,7 @@ const serializeAws_queryTagKeyList = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryTagMap = (input, context) => {
+const se_TagMap = (input, context) => {
     const entries = {};
     let counter = 1;
     Object.keys(input)
@@ -1675,13 +1675,13 @@ const serializeAws_queryTagMap = (input, context) => {
     });
     return entries;
 };
-const serializeAws_queryTagQueueRequest = (input, context) => {
+const se_TagQueueRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.Tags != null) {
-        const memberEntries = serializeAws_queryTagMap(input.Tags, context);
+        const memberEntries = se_TagMap(input.Tags, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `Tag.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
@@ -1689,13 +1689,13 @@ const serializeAws_queryTagQueueRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryUntagQueueRequest = (input, context) => {
+const se_UntagQueueRequest = (input, context) => {
     const entries = {};
     if (input.QueueUrl != null) {
         entries["QueueUrl"] = input.QueueUrl;
     }
     if (input.TagKeys != null) {
-        const memberEntries = serializeAws_queryTagKeyList(input.TagKeys, context);
+        const memberEntries = se_TagKeyList(input.TagKeys, context);
         if (input.TagKeys?.length === 0) {
             entries.TagKey = [];
         }
@@ -1706,15 +1706,15 @@ const serializeAws_queryUntagQueueRequest = (input, context) => {
     }
     return entries;
 };
-const deserializeAws_queryBatchEntryIdsNotDistinct = (output, context) => {
+const de_BatchEntryIdsNotDistinct = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryBatchRequestTooLong = (output, context) => {
+const de_BatchRequestTooLong = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryBatchResultErrorEntry = (output, context) => {
+const de_BatchResultErrorEntry = (output, context) => {
     const contents = {};
     if (output["Id"] !== undefined) {
         contents.Id = (0, smithy_client_1.expectString)(output["Id"]);
@@ -1730,138 +1730,138 @@ const deserializeAws_queryBatchResultErrorEntry = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryBatchResultErrorEntryList = (output, context) => {
+const de_BatchResultErrorEntryList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryBatchResultErrorEntry(entry, context);
+        return de_BatchResultErrorEntry(entry, context);
     });
 };
-const deserializeAws_queryBinaryList = (output, context) => {
+const de_BinaryList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         return context.base64Decoder(entry);
     });
 };
-const deserializeAws_queryChangeMessageVisibilityBatchResult = (output, context) => {
+const de_ChangeMessageVisibilityBatchResult = (output, context) => {
     const contents = {};
     if (output.ChangeMessageVisibilityBatchResultEntry === "") {
         contents.Successful = [];
     }
     else if (output["ChangeMessageVisibilityBatchResultEntry"] !== undefined) {
-        contents.Successful = deserializeAws_queryChangeMessageVisibilityBatchResultEntryList((0, smithy_client_1.getArrayIfSingleItem)(output["ChangeMessageVisibilityBatchResultEntry"]), context);
+        contents.Successful = de_ChangeMessageVisibilityBatchResultEntryList((0, smithy_client_1.getArrayIfSingleItem)(output["ChangeMessageVisibilityBatchResultEntry"]), context);
     }
     if (output.BatchResultErrorEntry === "") {
         contents.Failed = [];
     }
     else if (output["BatchResultErrorEntry"] !== undefined) {
-        contents.Failed = deserializeAws_queryBatchResultErrorEntryList((0, smithy_client_1.getArrayIfSingleItem)(output["BatchResultErrorEntry"]), context);
+        contents.Failed = de_BatchResultErrorEntryList((0, smithy_client_1.getArrayIfSingleItem)(output["BatchResultErrorEntry"]), context);
     }
     return contents;
 };
-const deserializeAws_queryChangeMessageVisibilityBatchResultEntry = (output, context) => {
+const de_ChangeMessageVisibilityBatchResultEntry = (output, context) => {
     const contents = {};
     if (output["Id"] !== undefined) {
         contents.Id = (0, smithy_client_1.expectString)(output["Id"]);
     }
     return contents;
 };
-const deserializeAws_queryChangeMessageVisibilityBatchResultEntryList = (output, context) => {
+const de_ChangeMessageVisibilityBatchResultEntryList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryChangeMessageVisibilityBatchResultEntry(entry, context);
+        return de_ChangeMessageVisibilityBatchResultEntry(entry, context);
     });
 };
-const deserializeAws_queryCreateQueueResult = (output, context) => {
+const de_CreateQueueResult = (output, context) => {
     const contents = {};
     if (output["QueueUrl"] !== undefined) {
         contents.QueueUrl = (0, smithy_client_1.expectString)(output["QueueUrl"]);
     }
     return contents;
 };
-const deserializeAws_queryDeleteMessageBatchResult = (output, context) => {
+const de_DeleteMessageBatchResult = (output, context) => {
     const contents = {};
     if (output.DeleteMessageBatchResultEntry === "") {
         contents.Successful = [];
     }
     else if (output["DeleteMessageBatchResultEntry"] !== undefined) {
-        contents.Successful = deserializeAws_queryDeleteMessageBatchResultEntryList((0, smithy_client_1.getArrayIfSingleItem)(output["DeleteMessageBatchResultEntry"]), context);
+        contents.Successful = de_DeleteMessageBatchResultEntryList((0, smithy_client_1.getArrayIfSingleItem)(output["DeleteMessageBatchResultEntry"]), context);
     }
     if (output.BatchResultErrorEntry === "") {
         contents.Failed = [];
     }
     else if (output["BatchResultErrorEntry"] !== undefined) {
-        contents.Failed = deserializeAws_queryBatchResultErrorEntryList((0, smithy_client_1.getArrayIfSingleItem)(output["BatchResultErrorEntry"]), context);
+        contents.Failed = de_BatchResultErrorEntryList((0, smithy_client_1.getArrayIfSingleItem)(output["BatchResultErrorEntry"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDeleteMessageBatchResultEntry = (output, context) => {
+const de_DeleteMessageBatchResultEntry = (output, context) => {
     const contents = {};
     if (output["Id"] !== undefined) {
         contents.Id = (0, smithy_client_1.expectString)(output["Id"]);
     }
     return contents;
 };
-const deserializeAws_queryDeleteMessageBatchResultEntryList = (output, context) => {
+const de_DeleteMessageBatchResultEntryList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryDeleteMessageBatchResultEntry(entry, context);
+        return de_DeleteMessageBatchResultEntry(entry, context);
     });
 };
-const deserializeAws_queryEmptyBatchRequest = (output, context) => {
+const de_EmptyBatchRequest = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryGetQueueAttributesResult = (output, context) => {
+const de_GetQueueAttributesResult = (output, context) => {
     const contents = {};
     if (output.Attribute === "") {
         contents.Attributes = {};
     }
     else if (output["Attribute"] !== undefined) {
-        contents.Attributes = deserializeAws_queryQueueAttributeMap((0, smithy_client_1.getArrayIfSingleItem)(output["Attribute"]), context);
+        contents.Attributes = de_QueueAttributeMap((0, smithy_client_1.getArrayIfSingleItem)(output["Attribute"]), context);
     }
     return contents;
 };
-const deserializeAws_queryGetQueueUrlResult = (output, context) => {
+const de_GetQueueUrlResult = (output, context) => {
     const contents = {};
     if (output["QueueUrl"] !== undefined) {
         contents.QueueUrl = (0, smithy_client_1.expectString)(output["QueueUrl"]);
     }
     return contents;
 };
-const deserializeAws_queryInvalidAttributeName = (output, context) => {
+const de_InvalidAttributeName = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryInvalidBatchEntryId = (output, context) => {
+const de_InvalidBatchEntryId = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryInvalidIdFormat = (output, context) => {
+const de_InvalidIdFormat = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryInvalidMessageContents = (output, context) => {
+const de_InvalidMessageContents = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryListDeadLetterSourceQueuesResult = (output, context) => {
+const de_ListDeadLetterSourceQueuesResult = (output, context) => {
     const contents = {};
     if (output.QueueUrl === "") {
         contents.queueUrls = [];
     }
     else if (output["QueueUrl"] !== undefined) {
-        contents.queueUrls = deserializeAws_queryQueueUrlList((0, smithy_client_1.getArrayIfSingleItem)(output["QueueUrl"]), context);
+        contents.queueUrls = de_QueueUrlList((0, smithy_client_1.getArrayIfSingleItem)(output["QueueUrl"]), context);
     }
     if (output["NextToken"] !== undefined) {
         contents.NextToken = (0, smithy_client_1.expectString)(output["NextToken"]);
     }
     return contents;
 };
-const deserializeAws_queryListQueuesResult = (output, context) => {
+const de_ListQueuesResult = (output, context) => {
     const contents = {};
     if (output["NextToken"] !== undefined) {
         contents.NextToken = (0, smithy_client_1.expectString)(output["NextToken"]);
@@ -1870,21 +1870,21 @@ const deserializeAws_queryListQueuesResult = (output, context) => {
         contents.QueueUrls = [];
     }
     else if (output["QueueUrl"] !== undefined) {
-        contents.QueueUrls = deserializeAws_queryQueueUrlList((0, smithy_client_1.getArrayIfSingleItem)(output["QueueUrl"]), context);
+        contents.QueueUrls = de_QueueUrlList((0, smithy_client_1.getArrayIfSingleItem)(output["QueueUrl"]), context);
     }
     return contents;
 };
-const deserializeAws_queryListQueueTagsResult = (output, context) => {
+const de_ListQueueTagsResult = (output, context) => {
     const contents = {};
     if (output.Tag === "") {
         contents.Tags = {};
     }
     else if (output["Tag"] !== undefined) {
-        contents.Tags = deserializeAws_queryTagMap((0, smithy_client_1.getArrayIfSingleItem)(output["Tag"]), context);
+        contents.Tags = de_TagMap((0, smithy_client_1.getArrayIfSingleItem)(output["Tag"]), context);
     }
     return contents;
 };
-const deserializeAws_queryMessage = (output, context) => {
+const de_Message = (output, context) => {
     const contents = {};
     if (output["MessageId"] !== undefined) {
         contents.MessageId = (0, smithy_client_1.expectString)(output["MessageId"]);
@@ -1902,7 +1902,7 @@ const deserializeAws_queryMessage = (output, context) => {
         contents.Attributes = {};
     }
     else if (output["Attribute"] !== undefined) {
-        contents.Attributes = deserializeAws_queryMessageSystemAttributeMap((0, smithy_client_1.getArrayIfSingleItem)(output["Attribute"]), context);
+        contents.Attributes = de_MessageSystemAttributeMap((0, smithy_client_1.getArrayIfSingleItem)(output["Attribute"]), context);
     }
     if (output["MD5OfMessageAttributes"] !== undefined) {
         contents.MD5OfMessageAttributes = (0, smithy_client_1.expectString)(output["MD5OfMessageAttributes"]);
@@ -1911,11 +1911,11 @@ const deserializeAws_queryMessage = (output, context) => {
         contents.MessageAttributes = {};
     }
     else if (output["MessageAttribute"] !== undefined) {
-        contents.MessageAttributes = deserializeAws_queryMessageBodyAttributeMap((0, smithy_client_1.getArrayIfSingleItem)(output["MessageAttribute"]), context);
+        contents.MessageAttributes = de_MessageBodyAttributeMap((0, smithy_client_1.getArrayIfSingleItem)(output["MessageAttribute"]), context);
     }
     return contents;
 };
-const deserializeAws_queryMessageAttributeValue = (output, context) => {
+const de_MessageAttributeValue = (output, context) => {
     const contents = {};
     if (output["StringValue"] !== undefined) {
         contents.StringValue = (0, smithy_client_1.expectString)(output["StringValue"]);
@@ -1927,40 +1927,40 @@ const deserializeAws_queryMessageAttributeValue = (output, context) => {
         contents.StringListValues = [];
     }
     else if (output["StringListValue"] !== undefined) {
-        contents.StringListValues = deserializeAws_queryStringList((0, smithy_client_1.getArrayIfSingleItem)(output["StringListValue"]), context);
+        contents.StringListValues = de_StringList((0, smithy_client_1.getArrayIfSingleItem)(output["StringListValue"]), context);
     }
     if (output.BinaryListValue === "") {
         contents.BinaryListValues = [];
     }
     else if (output["BinaryListValue"] !== undefined) {
-        contents.BinaryListValues = deserializeAws_queryBinaryList((0, smithy_client_1.getArrayIfSingleItem)(output["BinaryListValue"]), context);
+        contents.BinaryListValues = de_BinaryList((0, smithy_client_1.getArrayIfSingleItem)(output["BinaryListValue"]), context);
     }
     if (output["DataType"] !== undefined) {
         contents.DataType = (0, smithy_client_1.expectString)(output["DataType"]);
     }
     return contents;
 };
-const deserializeAws_queryMessageBodyAttributeMap = (output, context) => {
+const de_MessageBodyAttributeMap = (output, context) => {
     return output.reduce((acc, pair) => {
         if (pair["Value"] === null) {
             return acc;
         }
-        acc[pair["Name"]] = deserializeAws_queryMessageAttributeValue(pair["Value"], context);
+        acc[pair["Name"]] = de_MessageAttributeValue(pair["Value"], context);
         return acc;
     }, {});
 };
-const deserializeAws_queryMessageList = (output, context) => {
+const de_MessageList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryMessage(entry, context);
+        return de_Message(entry, context);
     });
 };
-const deserializeAws_queryMessageNotInflight = (output, context) => {
+const de_MessageNotInflight = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryMessageSystemAttributeMap = (output, context) => {
+const de_MessageSystemAttributeMap = (output, context) => {
     return output.reduce((acc, pair) => {
         if (pair["Value"] === null) {
             return acc;
@@ -1969,15 +1969,15 @@ const deserializeAws_queryMessageSystemAttributeMap = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_queryOverLimit = (output, context) => {
+const de_OverLimit = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryPurgeQueueInProgress = (output, context) => {
+const de_PurgeQueueInProgress = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryQueueAttributeMap = (output, context) => {
+const de_QueueAttributeMap = (output, context) => {
     return output.reduce((acc, pair) => {
         if (pair["Value"] === null) {
             return acc;
@@ -1986,56 +1986,56 @@ const deserializeAws_queryQueueAttributeMap = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_queryQueueDeletedRecently = (output, context) => {
+const de_QueueDeletedRecently = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryQueueDoesNotExist = (output, context) => {
+const de_QueueDoesNotExist = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryQueueNameExists = (output, context) => {
+const de_QueueNameExists = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryQueueUrlList = (output, context) => {
+const de_QueueUrlList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         return (0, smithy_client_1.expectString)(entry);
     });
 };
-const deserializeAws_queryReceiptHandleIsInvalid = (output, context) => {
+const de_ReceiptHandleIsInvalid = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryReceiveMessageResult = (output, context) => {
+const de_ReceiveMessageResult = (output, context) => {
     const contents = {};
     if (output.Message === "") {
         contents.Messages = [];
     }
     else if (output["Message"] !== undefined) {
-        contents.Messages = deserializeAws_queryMessageList((0, smithy_client_1.getArrayIfSingleItem)(output["Message"]), context);
+        contents.Messages = de_MessageList((0, smithy_client_1.getArrayIfSingleItem)(output["Message"]), context);
     }
     return contents;
 };
-const deserializeAws_querySendMessageBatchResult = (output, context) => {
+const de_SendMessageBatchResult = (output, context) => {
     const contents = {};
     if (output.SendMessageBatchResultEntry === "") {
         contents.Successful = [];
     }
     else if (output["SendMessageBatchResultEntry"] !== undefined) {
-        contents.Successful = deserializeAws_querySendMessageBatchResultEntryList((0, smithy_client_1.getArrayIfSingleItem)(output["SendMessageBatchResultEntry"]), context);
+        contents.Successful = de_SendMessageBatchResultEntryList((0, smithy_client_1.getArrayIfSingleItem)(output["SendMessageBatchResultEntry"]), context);
     }
     if (output.BatchResultErrorEntry === "") {
         contents.Failed = [];
     }
     else if (output["BatchResultErrorEntry"] !== undefined) {
-        contents.Failed = deserializeAws_queryBatchResultErrorEntryList((0, smithy_client_1.getArrayIfSingleItem)(output["BatchResultErrorEntry"]), context);
+        contents.Failed = de_BatchResultErrorEntryList((0, smithy_client_1.getArrayIfSingleItem)(output["BatchResultErrorEntry"]), context);
     }
     return contents;
 };
-const deserializeAws_querySendMessageBatchResultEntry = (output, context) => {
+const de_SendMessageBatchResultEntry = (output, context) => {
     const contents = {};
     if (output["Id"] !== undefined) {
         contents.Id = (0, smithy_client_1.expectString)(output["Id"]);
@@ -2057,14 +2057,14 @@ const deserializeAws_querySendMessageBatchResultEntry = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_querySendMessageBatchResultEntryList = (output, context) => {
+const de_SendMessageBatchResultEntryList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_querySendMessageBatchResultEntry(entry, context);
+        return de_SendMessageBatchResultEntry(entry, context);
     });
 };
-const deserializeAws_querySendMessageResult = (output, context) => {
+const de_SendMessageResult = (output, context) => {
     const contents = {};
     if (output["MD5OfMessageBody"] !== undefined) {
         contents.MD5OfMessageBody = (0, smithy_client_1.expectString)(output["MD5OfMessageBody"]);
@@ -2083,14 +2083,14 @@ const deserializeAws_querySendMessageResult = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryStringList = (output, context) => {
+const de_StringList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         return (0, smithy_client_1.expectString)(entry);
     });
 };
-const deserializeAws_queryTagMap = (output, context) => {
+const de_TagMap = (output, context) => {
     return output.reduce((acc, pair) => {
         if (pair["Value"] === null) {
             return acc;
@@ -2099,11 +2099,11 @@ const deserializeAws_queryTagMap = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_queryTooManyEntriesInBatchRequest = (output, context) => {
+const de_TooManyEntriesInBatchRequest = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryUnsupportedOperation = (output, context) => {
+const de_UnsupportedOperation = (output, context) => {
     const contents = {};
     return contents;
 };