@aws-sdk/client-sqs 3.306.0 → 3.309.0

package/dist-es/protocols/Aws_query.js

@@ -3,249 +3,249 @@ import { decorateServiceException as __decorateServiceException, expectString as
 import { XMLParser } from "fast-xml-parser";
 import { BatchEntryIdsNotDistinct, BatchRequestTooLong, EmptyBatchRequest, InvalidAttributeName, InvalidBatchEntryId, InvalidIdFormat, InvalidMessageContents, MessageNotInflight, OverLimit, PurgeQueueInProgress, QueueDeletedRecently, QueueDoesNotExist, QueueNameExists, ReceiptHandleIsInvalid, TooManyEntriesInBatchRequest, UnsupportedOperation, } from "../models/models_0";
 import { SQSServiceException as __BaseException } from "../models/SQSServiceException";
-export const serializeAws_queryAddPermissionCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_queryChangeMessageVisibilityCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_queryChangeMessageVisibilityBatchCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_queryCreateQueueCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_queryDeleteMessageCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_queryDeleteMessageBatchCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_queryDeleteQueueCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_queryGetQueueAttributesCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_queryGetQueueUrlCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_queryListDeadLetterSourceQueuesCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_queryListQueuesCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_queryListQueueTagsCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_queryPurgeQueueCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_queryReceiveMessageCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_queryRemovePermissionCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_querySendMessageCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_querySendMessageBatchCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_querySetQueueAttributesCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_queryTagQueueCommand = async (input, context) => {
+export 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);
 };
-export const serializeAws_queryUntagQueueCommand = async (input, context) => {
+export 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);
 };
-export const deserializeAws_queryAddPermissionCommand = async (output, context) => {
+export 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 = {
@@ -253,7 +253,7 @@ export const deserializeAws_queryAddPermissionCommand = async (output, context)
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryAddPermissionCommandError = async (output, context) => {
+const de_AddPermissionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -262,7 +262,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;
             throwDefaultError({
@@ -273,9 +273,9 @@ const deserializeAws_queryAddPermissionCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_queryChangeMessageVisibilityCommand = async (output, context) => {
+export 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 = {
@@ -283,7 +283,7 @@ export const deserializeAws_queryChangeMessageVisibilityCommand = async (output,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryChangeMessageVisibilityCommandError = async (output, context) => {
+const de_ChangeMessageVisibilityCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -292,10 +292,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;
             throwDefaultError({
@@ -306,20 +306,20 @@ const deserializeAws_queryChangeMessageVisibilityCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_queryChangeMessageVisibilityBatchCommand = async (output, context) => {
+export 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);
 };
-const deserializeAws_queryChangeMessageVisibilityBatchCommandError = async (output, context) => {
+const de_ChangeMessageVisibilityBatchCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -328,16 +328,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;
             throwDefaultError({
@@ -348,20 +348,20 @@ const deserializeAws_queryChangeMessageVisibilityBatchCommandError = async (outp
             });
     }
 };
-export const deserializeAws_queryCreateQueueCommand = async (output, context) => {
+export 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);
 };
-const deserializeAws_queryCreateQueueCommandError = async (output, context) => {
+const de_CreateQueueCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -370,10 +370,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;
             throwDefaultError({
@@ -384,9 +384,9 @@ const deserializeAws_queryCreateQueueCommandError = async (output, context) => {
             });
     }
 };
-export const deserializeAws_queryDeleteMessageCommand = async (output, context) => {
+export 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 = {
@@ -394,7 +394,7 @@ export const deserializeAws_queryDeleteMessageCommand = async (output, context)
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDeleteMessageCommandError = async (output, context) => {
+const de_DeleteMessageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -403,10 +403,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;
             throwDefaultError({
@@ -417,20 +417,20 @@ const deserializeAws_queryDeleteMessageCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_queryDeleteMessageBatchCommand = async (output, context) => {
+export 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);
 };
-const deserializeAws_queryDeleteMessageBatchCommandError = async (output, context) => {
+const de_DeleteMessageBatchCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -439,16 +439,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;
             throwDefaultError({
@@ -459,9 +459,9 @@ const deserializeAws_queryDeleteMessageBatchCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_queryDeleteQueueCommand = async (output, context) => {
+export 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 = {
@@ -469,7 +469,7 @@ export const deserializeAws_queryDeleteQueueCommand = async (output, context) =>
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDeleteQueueCommandError = async (output, context) => {
+const de_DeleteQueueCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -483,20 +483,20 @@ const deserializeAws_queryDeleteQueueCommandError = async (output, context) => {
         errorCode,
     });
 };
-export const deserializeAws_queryGetQueueAttributesCommand = async (output, context) => {
+export 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);
 };
-const deserializeAws_queryGetQueueAttributesCommandError = async (output, context) => {
+const de_GetQueueAttributesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -505,7 +505,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;
             throwDefaultError({
@@ -516,20 +516,20 @@ const deserializeAws_queryGetQueueAttributesCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_queryGetQueueUrlCommand = async (output, context) => {
+export 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);
 };
-const deserializeAws_queryGetQueueUrlCommandError = async (output, context) => {
+const de_GetQueueUrlCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -538,7 +538,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;
             throwDefaultError({
@@ -549,20 +549,20 @@ const deserializeAws_queryGetQueueUrlCommandError = async (output, context) => {
             });
     }
 };
-export const deserializeAws_queryListDeadLetterSourceQueuesCommand = async (output, context) => {
+export 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);
 };
-const deserializeAws_queryListDeadLetterSourceQueuesCommandError = async (output, context) => {
+const de_ListDeadLetterSourceQueuesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -571,7 +571,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;
             throwDefaultError({
@@ -582,20 +582,20 @@ const deserializeAws_queryListDeadLetterSourceQueuesCommandError = async (output
             });
     }
 };
-export const deserializeAws_queryListQueuesCommand = async (output, context) => {
+export 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);
 };
-const deserializeAws_queryListQueuesCommandError = async (output, context) => {
+const de_ListQueuesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -609,20 +609,20 @@ const deserializeAws_queryListQueuesCommandError = async (output, context) => {
         errorCode,
     });
 };
-export const deserializeAws_queryListQueueTagsCommand = async (output, context) => {
+export 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);
 };
-const deserializeAws_queryListQueueTagsCommandError = async (output, context) => {
+const de_ListQueueTagsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -636,9 +636,9 @@ const deserializeAws_queryListQueueTagsCommandError = async (output, context) =>
         errorCode,
     });
 };
-export const deserializeAws_queryPurgeQueueCommand = async (output, context) => {
+export 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 = {
@@ -646,7 +646,7 @@ export const deserializeAws_queryPurgeQueueCommand = async (output, context) =>
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryPurgeQueueCommandError = async (output, context) => {
+const de_PurgeQueueCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -655,10 +655,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;
             throwDefaultError({
@@ -669,20 +669,20 @@ const deserializeAws_queryPurgeQueueCommandError = async (output, context) => {
             });
     }
 };
-export const deserializeAws_queryReceiveMessageCommand = async (output, context) => {
+export 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);
 };
-const deserializeAws_queryReceiveMessageCommandError = async (output, context) => {
+const de_ReceiveMessageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -691,7 +691,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;
             throwDefaultError({
@@ -702,9 +702,9 @@ const deserializeAws_queryReceiveMessageCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_queryRemovePermissionCommand = async (output, context) => {
+export 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 = {
@@ -712,7 +712,7 @@ export const deserializeAws_queryRemovePermissionCommand = async (output, contex
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryRemovePermissionCommandError = async (output, context) => {
+const de_RemovePermissionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -726,20 +726,20 @@ const deserializeAws_queryRemovePermissionCommandError = async (output, context)
         errorCode,
     });
 };
-export const deserializeAws_querySendMessageCommand = async (output, context) => {
+export 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);
 };
-const deserializeAws_querySendMessageCommandError = async (output, context) => {
+const de_SendMessageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -748,10 +748,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;
             throwDefaultError({
@@ -762,20 +762,20 @@ const deserializeAws_querySendMessageCommandError = async (output, context) => {
             });
     }
 };
-export const deserializeAws_querySendMessageBatchCommand = async (output, context) => {
+export 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);
 };
-const deserializeAws_querySendMessageBatchCommandError = async (output, context) => {
+const de_SendMessageBatchCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -784,22 +784,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;
             throwDefaultError({
@@ -810,9 +810,9 @@ const deserializeAws_querySendMessageBatchCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_querySetQueueAttributesCommand = async (output, context) => {
+export 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 = {
@@ -820,7 +820,7 @@ export const deserializeAws_querySetQueueAttributesCommand = async (output, cont
     };
     return Promise.resolve(response);
 };
-const deserializeAws_querySetQueueAttributesCommandError = async (output, context) => {
+const de_SetQueueAttributesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -829,7 +829,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;
             throwDefaultError({
@@ -840,9 +840,9 @@ const deserializeAws_querySetQueueAttributesCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_queryTagQueueCommand = async (output, context) => {
+export 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 = {
@@ -850,7 +850,7 @@ export const deserializeAws_queryTagQueueCommand = async (output, context) => {
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryTagQueueCommandError = async (output, context) => {
+const de_TagQueueCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -864,9 +864,9 @@ const deserializeAws_queryTagQueueCommandError = async (output, context) => {
         errorCode,
     });
 };
-export const deserializeAws_queryUntagQueueCommand = async (output, context) => {
+export 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 = {
@@ -874,7 +874,7 @@ export const deserializeAws_queryUntagQueueCommand = async (output, context) =>
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryUntagQueueCommandError = async (output, context) => {
+const de_UntagQueueCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -888,151 +888,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 BatchEntryIdsNotDistinct({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __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 BatchRequestTooLong({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __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 EmptyBatchRequest({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __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 InvalidAttributeName({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __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 InvalidBatchEntryId({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __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 InvalidIdFormat({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __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 InvalidMessageContents({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __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 MessageNotInflight({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __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 OverLimit({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __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 PurgeQueueInProgress({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __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 QueueDeletedRecently({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __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 QueueDoesNotExist({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __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 QueueNameExists({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __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 ReceiptHandleIsInvalid({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __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 TooManyEntriesInBatchRequest({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __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 UnsupportedOperation({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const serializeAws_queryActionNameList = (input, context) => {
+const se_ActionNameList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -1044,7 +1044,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;
@@ -1053,7 +1053,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 = [];
         }
@@ -1063,7 +1063,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 = [];
         }
@@ -1074,7 +1074,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) {
@@ -1086,7 +1086,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) {
@@ -1098,7 +1098,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) {
@@ -1110,13 +1110,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 = [];
         }
@@ -1127,7 +1127,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;
@@ -1140,14 +1140,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;
         });
@@ -1155,7 +1155,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;
@@ -1168,20 +1168,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;
@@ -1189,13 +1189,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 = [];
         }
@@ -1206,7 +1206,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;
@@ -1216,14 +1216,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;
         });
@@ -1231,7 +1231,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;
@@ -1241,20 +1241,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 = [];
         }
@@ -1265,7 +1265,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;
@@ -1275,7 +1275,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;
@@ -1288,7 +1288,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;
@@ -1301,14 +1301,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) {
@@ -1320,7 +1320,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;
@@ -1329,7 +1329,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 = [];
         }
@@ -1339,7 +1339,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 = [];
         }
@@ -1353,14 +1353,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;
         });
@@ -1368,14 +1368,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;
         });
@@ -1383,7 +1383,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;
@@ -1392,7 +1392,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 = [];
         }
@@ -1402,7 +1402,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 = [];
         }
@@ -1416,14 +1416,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)
@@ -1435,13 +1435,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 = [];
         }
@@ -1451,7 +1451,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 = [];
         }
@@ -1474,7 +1474,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;
@@ -1484,13 +1484,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 = [];
         }
@@ -1501,7 +1501,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;
@@ -1513,14 +1513,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;
@@ -1534,14 +1534,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;
         });
@@ -1549,7 +1549,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;
@@ -1561,14 +1561,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;
@@ -1582,13 +1582,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;
@@ -1596,7 +1596,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) {
@@ -1608,7 +1608,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) {
@@ -1620,7 +1620,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)
@@ -1632,13 +1632,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;
@@ -1646,13 +1646,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 = [];
         }
@@ -1663,15 +1663,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 = __expectString(output["Id"]);
@@ -1687,138 +1687,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(__getArrayIfSingleItem(output["ChangeMessageVisibilityBatchResultEntry"]), context);
+        contents.Successful = de_ChangeMessageVisibilityBatchResultEntryList(__getArrayIfSingleItem(output["ChangeMessageVisibilityBatchResultEntry"]), context);
     }
     if (output.BatchResultErrorEntry === "") {
         contents.Failed = [];
     }
     else if (output["BatchResultErrorEntry"] !== undefined) {
-        contents.Failed = deserializeAws_queryBatchResultErrorEntryList(__getArrayIfSingleItem(output["BatchResultErrorEntry"]), context);
+        contents.Failed = de_BatchResultErrorEntryList(__getArrayIfSingleItem(output["BatchResultErrorEntry"]), context);
     }
     return contents;
 };
-const deserializeAws_queryChangeMessageVisibilityBatchResultEntry = (output, context) => {
+const de_ChangeMessageVisibilityBatchResultEntry = (output, context) => {
     const contents = {};
     if (output["Id"] !== undefined) {
         contents.Id = __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 = __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(__getArrayIfSingleItem(output["DeleteMessageBatchResultEntry"]), context);
+        contents.Successful = de_DeleteMessageBatchResultEntryList(__getArrayIfSingleItem(output["DeleteMessageBatchResultEntry"]), context);
     }
     if (output.BatchResultErrorEntry === "") {
         contents.Failed = [];
     }
     else if (output["BatchResultErrorEntry"] !== undefined) {
-        contents.Failed = deserializeAws_queryBatchResultErrorEntryList(__getArrayIfSingleItem(output["BatchResultErrorEntry"]), context);
+        contents.Failed = de_BatchResultErrorEntryList(__getArrayIfSingleItem(output["BatchResultErrorEntry"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDeleteMessageBatchResultEntry = (output, context) => {
+const de_DeleteMessageBatchResultEntry = (output, context) => {
     const contents = {};
     if (output["Id"] !== undefined) {
         contents.Id = __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(__getArrayIfSingleItem(output["Attribute"]), context);
+        contents.Attributes = de_QueueAttributeMap(__getArrayIfSingleItem(output["Attribute"]), context);
     }
     return contents;
 };
-const deserializeAws_queryGetQueueUrlResult = (output, context) => {
+const de_GetQueueUrlResult = (output, context) => {
     const contents = {};
     if (output["QueueUrl"] !== undefined) {
         contents.QueueUrl = __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(__getArrayIfSingleItem(output["QueueUrl"]), context);
+        contents.queueUrls = de_QueueUrlList(__getArrayIfSingleItem(output["QueueUrl"]), context);
     }
     if (output["NextToken"] !== undefined) {
         contents.NextToken = __expectString(output["NextToken"]);
     }
     return contents;
 };
-const deserializeAws_queryListQueuesResult = (output, context) => {
+const de_ListQueuesResult = (output, context) => {
     const contents = {};
     if (output["NextToken"] !== undefined) {
         contents.NextToken = __expectString(output["NextToken"]);
@@ -1827,21 +1827,21 @@ const deserializeAws_queryListQueuesResult = (output, context) => {
         contents.QueueUrls = [];
     }
     else if (output["QueueUrl"] !== undefined) {
-        contents.QueueUrls = deserializeAws_queryQueueUrlList(__getArrayIfSingleItem(output["QueueUrl"]), context);
+        contents.QueueUrls = de_QueueUrlList(__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(__getArrayIfSingleItem(output["Tag"]), context);
+        contents.Tags = de_TagMap(__getArrayIfSingleItem(output["Tag"]), context);
     }
     return contents;
 };
-const deserializeAws_queryMessage = (output, context) => {
+const de_Message = (output, context) => {
     const contents = {};
     if (output["MessageId"] !== undefined) {
         contents.MessageId = __expectString(output["MessageId"]);
@@ -1859,7 +1859,7 @@ const deserializeAws_queryMessage = (output, context) => {
         contents.Attributes = {};
     }
     else if (output["Attribute"] !== undefined) {
-        contents.Attributes = deserializeAws_queryMessageSystemAttributeMap(__getArrayIfSingleItem(output["Attribute"]), context);
+        contents.Attributes = de_MessageSystemAttributeMap(__getArrayIfSingleItem(output["Attribute"]), context);
     }
     if (output["MD5OfMessageAttributes"] !== undefined) {
         contents.MD5OfMessageAttributes = __expectString(output["MD5OfMessageAttributes"]);
@@ -1868,11 +1868,11 @@ const deserializeAws_queryMessage = (output, context) => {
         contents.MessageAttributes = {};
     }
     else if (output["MessageAttribute"] !== undefined) {
-        contents.MessageAttributes = deserializeAws_queryMessageBodyAttributeMap(__getArrayIfSingleItem(output["MessageAttribute"]), context);
+        contents.MessageAttributes = de_MessageBodyAttributeMap(__getArrayIfSingleItem(output["MessageAttribute"]), context);
     }
     return contents;
 };
-const deserializeAws_queryMessageAttributeValue = (output, context) => {
+const de_MessageAttributeValue = (output, context) => {
     const contents = {};
     if (output["StringValue"] !== undefined) {
         contents.StringValue = __expectString(output["StringValue"]);
@@ -1884,40 +1884,40 @@ const deserializeAws_queryMessageAttributeValue = (output, context) => {
         contents.StringListValues = [];
     }
     else if (output["StringListValue"] !== undefined) {
-        contents.StringListValues = deserializeAws_queryStringList(__getArrayIfSingleItem(output["StringListValue"]), context);
+        contents.StringListValues = de_StringList(__getArrayIfSingleItem(output["StringListValue"]), context);
     }
     if (output.BinaryListValue === "") {
         contents.BinaryListValues = [];
     }
     else if (output["BinaryListValue"] !== undefined) {
-        contents.BinaryListValues = deserializeAws_queryBinaryList(__getArrayIfSingleItem(output["BinaryListValue"]), context);
+        contents.BinaryListValues = de_BinaryList(__getArrayIfSingleItem(output["BinaryListValue"]), context);
     }
     if (output["DataType"] !== undefined) {
         contents.DataType = __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;
@@ -1926,15 +1926,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;
@@ -1943,56 +1943,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 __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(__getArrayIfSingleItem(output["Message"]), context);
+        contents.Messages = de_MessageList(__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(__getArrayIfSingleItem(output["SendMessageBatchResultEntry"]), context);
+        contents.Successful = de_SendMessageBatchResultEntryList(__getArrayIfSingleItem(output["SendMessageBatchResultEntry"]), context);
     }
     if (output.BatchResultErrorEntry === "") {
         contents.Failed = [];
     }
     else if (output["BatchResultErrorEntry"] !== undefined) {
-        contents.Failed = deserializeAws_queryBatchResultErrorEntryList(__getArrayIfSingleItem(output["BatchResultErrorEntry"]), context);
+        contents.Failed = de_BatchResultErrorEntryList(__getArrayIfSingleItem(output["BatchResultErrorEntry"]), context);
     }
     return contents;
 };
-const deserializeAws_querySendMessageBatchResultEntry = (output, context) => {
+const de_SendMessageBatchResultEntry = (output, context) => {
     const contents = {};
     if (output["Id"] !== undefined) {
         contents.Id = __expectString(output["Id"]);
@@ -2014,14 +2014,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 = __expectString(output["MD5OfMessageBody"]);
@@ -2040,14 +2040,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 __expectString(entry);
     });
 };
-const deserializeAws_queryTagMap = (output, context) => {
+const de_TagMap = (output, context) => {
     return output.reduce((acc, pair) => {
         if (pair["Value"] === null) {
             return acc;
@@ -2056,11 +2056,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;
 };