@aws-sdk/client-cloudsearch 3.306.0 → 3.309.0

package/dist-es/protocols/Aws_query.js

@@ -3,259 +3,259 @@ import { decorateServiceException as __decorateServiceException, expectNonNull a
 import { XMLParser } from "fast-xml-parser";
 import { CloudSearchServiceException as __BaseException } from "../models/CloudSearchServiceException";
 import { BaseException, DisabledOperationException, InternalException, InvalidTypeException, LimitExceededException, ResourceAlreadyExistsException, ResourceNotFoundException, ValidationException, } from "../models/models_0";
-export const serializeAws_queryBuildSuggestersCommand = async (input, context) => {
+export const se_BuildSuggestersCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryBuildSuggestersRequest(input, context),
+        ...se_BuildSuggestersRequest(input, context),
         Action: "BuildSuggesters",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryCreateDomainCommand = async (input, context) => {
+export const se_CreateDomainCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryCreateDomainRequest(input, context),
+        ...se_CreateDomainRequest(input, context),
         Action: "CreateDomain",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDefineAnalysisSchemeCommand = async (input, context) => {
+export const se_DefineAnalysisSchemeCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDefineAnalysisSchemeRequest(input, context),
+        ...se_DefineAnalysisSchemeRequest(input, context),
         Action: "DefineAnalysisScheme",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDefineExpressionCommand = async (input, context) => {
+export const se_DefineExpressionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDefineExpressionRequest(input, context),
+        ...se_DefineExpressionRequest(input, context),
         Action: "DefineExpression",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDefineIndexFieldCommand = async (input, context) => {
+export const se_DefineIndexFieldCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDefineIndexFieldRequest(input, context),
+        ...se_DefineIndexFieldRequest(input, context),
         Action: "DefineIndexField",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDefineSuggesterCommand = async (input, context) => {
+export const se_DefineSuggesterCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDefineSuggesterRequest(input, context),
+        ...se_DefineSuggesterRequest(input, context),
         Action: "DefineSuggester",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDeleteAnalysisSchemeCommand = async (input, context) => {
+export const se_DeleteAnalysisSchemeCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteAnalysisSchemeRequest(input, context),
+        ...se_DeleteAnalysisSchemeRequest(input, context),
         Action: "DeleteAnalysisScheme",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDeleteDomainCommand = async (input, context) => {
+export const se_DeleteDomainCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteDomainRequest(input, context),
+        ...se_DeleteDomainRequest(input, context),
         Action: "DeleteDomain",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDeleteExpressionCommand = async (input, context) => {
+export const se_DeleteExpressionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteExpressionRequest(input, context),
+        ...se_DeleteExpressionRequest(input, context),
         Action: "DeleteExpression",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDeleteIndexFieldCommand = async (input, context) => {
+export const se_DeleteIndexFieldCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteIndexFieldRequest(input, context),
+        ...se_DeleteIndexFieldRequest(input, context),
         Action: "DeleteIndexField",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDeleteSuggesterCommand = async (input, context) => {
+export const se_DeleteSuggesterCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteSuggesterRequest(input, context),
+        ...se_DeleteSuggesterRequest(input, context),
         Action: "DeleteSuggester",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeAnalysisSchemesCommand = async (input, context) => {
+export const se_DescribeAnalysisSchemesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeAnalysisSchemesRequest(input, context),
+        ...se_DescribeAnalysisSchemesRequest(input, context),
         Action: "DescribeAnalysisSchemes",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeAvailabilityOptionsCommand = async (input, context) => {
+export const se_DescribeAvailabilityOptionsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeAvailabilityOptionsRequest(input, context),
+        ...se_DescribeAvailabilityOptionsRequest(input, context),
         Action: "DescribeAvailabilityOptions",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeDomainEndpointOptionsCommand = async (input, context) => {
+export const se_DescribeDomainEndpointOptionsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeDomainEndpointOptionsRequest(input, context),
+        ...se_DescribeDomainEndpointOptionsRequest(input, context),
         Action: "DescribeDomainEndpointOptions",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeDomainsCommand = async (input, context) => {
+export const se_DescribeDomainsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeDomainsRequest(input, context),
+        ...se_DescribeDomainsRequest(input, context),
         Action: "DescribeDomains",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeExpressionsCommand = async (input, context) => {
+export const se_DescribeExpressionsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeExpressionsRequest(input, context),
+        ...se_DescribeExpressionsRequest(input, context),
         Action: "DescribeExpressions",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeIndexFieldsCommand = async (input, context) => {
+export const se_DescribeIndexFieldsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeIndexFieldsRequest(input, context),
+        ...se_DescribeIndexFieldsRequest(input, context),
         Action: "DescribeIndexFields",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeScalingParametersCommand = async (input, context) => {
+export const se_DescribeScalingParametersCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeScalingParametersRequest(input, context),
+        ...se_DescribeScalingParametersRequest(input, context),
         Action: "DescribeScalingParameters",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeServiceAccessPoliciesCommand = async (input, context) => {
+export const se_DescribeServiceAccessPoliciesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeServiceAccessPoliciesRequest(input, context),
+        ...se_DescribeServiceAccessPoliciesRequest(input, context),
         Action: "DescribeServiceAccessPolicies",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeSuggestersCommand = async (input, context) => {
+export const se_DescribeSuggestersCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeSuggestersRequest(input, context),
+        ...se_DescribeSuggestersRequest(input, context),
         Action: "DescribeSuggesters",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryIndexDocumentsCommand = async (input, context) => {
+export const se_IndexDocumentsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryIndexDocumentsRequest(input, context),
+        ...se_IndexDocumentsRequest(input, context),
         Action: "IndexDocuments",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryListDomainNamesCommand = async (input, context) => {
+export const se_ListDomainNamesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
@@ -265,68 +265,68 @@ export const serializeAws_queryListDomainNamesCommand = async (input, context) =
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryUpdateAvailabilityOptionsCommand = async (input, context) => {
+export const se_UpdateAvailabilityOptionsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryUpdateAvailabilityOptionsRequest(input, context),
+        ...se_UpdateAvailabilityOptionsRequest(input, context),
         Action: "UpdateAvailabilityOptions",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryUpdateDomainEndpointOptionsCommand = async (input, context) => {
+export const se_UpdateDomainEndpointOptionsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryUpdateDomainEndpointOptionsRequest(input, context),
+        ...se_UpdateDomainEndpointOptionsRequest(input, context),
         Action: "UpdateDomainEndpointOptions",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryUpdateScalingParametersCommand = async (input, context) => {
+export const se_UpdateScalingParametersCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryUpdateScalingParametersRequest(input, context),
+        ...se_UpdateScalingParametersRequest(input, context),
         Action: "UpdateScalingParameters",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryUpdateServiceAccessPoliciesCommand = async (input, context) => {
+export const se_UpdateServiceAccessPoliciesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryUpdateServiceAccessPoliciesRequest(input, context),
+        ...se_UpdateServiceAccessPoliciesRequest(input, context),
         Action: "UpdateServiceAccessPolicies",
         Version: "2013-01-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const deserializeAws_queryBuildSuggestersCommand = async (output, context) => {
+export const de_BuildSuggestersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryBuildSuggestersCommandError(output, context);
+        return de_BuildSuggestersCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryBuildSuggestersResponse(data.BuildSuggestersResult, context);
+    contents = de_BuildSuggestersResponse(data.BuildSuggestersResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryBuildSuggestersCommandError = async (output, context) => {
+const de_BuildSuggestersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -335,16 +335,16 @@ const deserializeAws_queryBuildSuggestersCommandError = async (output, context)
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cloudsearch#ValidationException":
-            throw await deserializeAws_queryValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -355,20 +355,20 @@ const deserializeAws_queryBuildSuggestersCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_queryCreateDomainCommand = async (output, context) => {
+export const de_CreateDomainCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryCreateDomainCommandError(output, context);
+        return de_CreateDomainCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryCreateDomainResponse(data.CreateDomainResult, context);
+    contents = de_CreateDomainResponse(data.CreateDomainResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryCreateDomainCommandError = async (output, context) => {
+const de_CreateDomainCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -377,19 +377,19 @@ const deserializeAws_queryCreateDomainCommandError = async (output, context) =>
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "LimitExceeded":
         case "com.amazonaws.cloudsearch#LimitExceededException":
-            throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceAlreadyExists":
         case "com.amazonaws.cloudsearch#ResourceAlreadyExistsException":
-            throw await deserializeAws_queryResourceAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cloudsearch#ValidationException":
-            throw await deserializeAws_queryValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -400,20 +400,20 @@ const deserializeAws_queryCreateDomainCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_queryDefineAnalysisSchemeCommand = async (output, context) => {
+export const de_DefineAnalysisSchemeCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDefineAnalysisSchemeCommandError(output, context);
+        return de_DefineAnalysisSchemeCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDefineAnalysisSchemeResponse(data.DefineAnalysisSchemeResult, context);
+    contents = de_DefineAnalysisSchemeResponse(data.DefineAnalysisSchemeResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDefineAnalysisSchemeCommandError = async (output, context) => {
+const de_DefineAnalysisSchemeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -422,22 +422,22 @@ const deserializeAws_queryDefineAnalysisSchemeCommandError = async (output, cont
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidType":
         case "com.amazonaws.cloudsearch#InvalidTypeException":
-            throw await deserializeAws_queryInvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "LimitExceeded":
         case "com.amazonaws.cloudsearch#LimitExceededException":
-            throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cloudsearch#ValidationException":
-            throw await deserializeAws_queryValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -448,20 +448,20 @@ const deserializeAws_queryDefineAnalysisSchemeCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_queryDefineExpressionCommand = async (output, context) => {
+export const de_DefineExpressionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDefineExpressionCommandError(output, context);
+        return de_DefineExpressionCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDefineExpressionResponse(data.DefineExpressionResult, context);
+    contents = de_DefineExpressionResponse(data.DefineExpressionResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDefineExpressionCommandError = async (output, context) => {
+const de_DefineExpressionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -470,22 +470,22 @@ const deserializeAws_queryDefineExpressionCommandError = async (output, context)
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidType":
         case "com.amazonaws.cloudsearch#InvalidTypeException":
-            throw await deserializeAws_queryInvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "LimitExceeded":
         case "com.amazonaws.cloudsearch#LimitExceededException":
-            throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cloudsearch#ValidationException":
-            throw await deserializeAws_queryValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -496,20 +496,20 @@ const deserializeAws_queryDefineExpressionCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_queryDefineIndexFieldCommand = async (output, context) => {
+export const de_DefineIndexFieldCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDefineIndexFieldCommandError(output, context);
+        return de_DefineIndexFieldCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDefineIndexFieldResponse(data.DefineIndexFieldResult, context);
+    contents = de_DefineIndexFieldResponse(data.DefineIndexFieldResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDefineIndexFieldCommandError = async (output, context) => {
+const de_DefineIndexFieldCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -518,22 +518,22 @@ const deserializeAws_queryDefineIndexFieldCommandError = async (output, context)
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidType":
         case "com.amazonaws.cloudsearch#InvalidTypeException":
-            throw await deserializeAws_queryInvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "LimitExceeded":
         case "com.amazonaws.cloudsearch#LimitExceededException":
-            throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cloudsearch#ValidationException":
-            throw await deserializeAws_queryValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -544,20 +544,20 @@ const deserializeAws_queryDefineIndexFieldCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_queryDefineSuggesterCommand = async (output, context) => {
+export const de_DefineSuggesterCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDefineSuggesterCommandError(output, context);
+        return de_DefineSuggesterCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDefineSuggesterResponse(data.DefineSuggesterResult, context);
+    contents = de_DefineSuggesterResponse(data.DefineSuggesterResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDefineSuggesterCommandError = async (output, context) => {
+const de_DefineSuggesterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -566,22 +566,22 @@ const deserializeAws_queryDefineSuggesterCommandError = async (output, context)
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidType":
         case "com.amazonaws.cloudsearch#InvalidTypeException":
-            throw await deserializeAws_queryInvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "LimitExceeded":
         case "com.amazonaws.cloudsearch#LimitExceededException":
-            throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cloudsearch#ValidationException":
-            throw await deserializeAws_queryValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -592,20 +592,20 @@ const deserializeAws_queryDefineSuggesterCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_queryDeleteAnalysisSchemeCommand = async (output, context) => {
+export const de_DeleteAnalysisSchemeCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteAnalysisSchemeCommandError(output, context);
+        return de_DeleteAnalysisSchemeCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDeleteAnalysisSchemeResponse(data.DeleteAnalysisSchemeResult, context);
+    contents = de_DeleteAnalysisSchemeResponse(data.DeleteAnalysisSchemeResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDeleteAnalysisSchemeCommandError = async (output, context) => {
+const de_DeleteAnalysisSchemeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -614,19 +614,19 @@ const deserializeAws_queryDeleteAnalysisSchemeCommandError = async (output, cont
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidType":
         case "com.amazonaws.cloudsearch#InvalidTypeException":
-            throw await deserializeAws_queryInvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cloudsearch#ValidationException":
-            throw await deserializeAws_queryValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -637,20 +637,20 @@ const deserializeAws_queryDeleteAnalysisSchemeCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_queryDeleteDomainCommand = async (output, context) => {
+export const de_DeleteDomainCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteDomainCommandError(output, context);
+        return de_DeleteDomainCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDeleteDomainResponse(data.DeleteDomainResult, context);
+    contents = de_DeleteDomainResponse(data.DeleteDomainResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDeleteDomainCommandError = async (output, context) => {
+const de_DeleteDomainCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -659,10 +659,10 @@ const deserializeAws_queryDeleteDomainCommandError = async (output, context) =>
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -673,20 +673,20 @@ const deserializeAws_queryDeleteDomainCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_queryDeleteExpressionCommand = async (output, context) => {
+export const de_DeleteExpressionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteExpressionCommandError(output, context);
+        return de_DeleteExpressionCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDeleteExpressionResponse(data.DeleteExpressionResult, context);
+    contents = de_DeleteExpressionResponse(data.DeleteExpressionResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDeleteExpressionCommandError = async (output, context) => {
+const de_DeleteExpressionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -695,19 +695,19 @@ const deserializeAws_queryDeleteExpressionCommandError = async (output, context)
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidType":
         case "com.amazonaws.cloudsearch#InvalidTypeException":
-            throw await deserializeAws_queryInvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cloudsearch#ValidationException":
-            throw await deserializeAws_queryValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -718,20 +718,20 @@ const deserializeAws_queryDeleteExpressionCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_queryDeleteIndexFieldCommand = async (output, context) => {
+export const de_DeleteIndexFieldCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteIndexFieldCommandError(output, context);
+        return de_DeleteIndexFieldCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDeleteIndexFieldResponse(data.DeleteIndexFieldResult, context);
+    contents = de_DeleteIndexFieldResponse(data.DeleteIndexFieldResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDeleteIndexFieldCommandError = async (output, context) => {
+const de_DeleteIndexFieldCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -740,19 +740,19 @@ const deserializeAws_queryDeleteIndexFieldCommandError = async (output, context)
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidType":
         case "com.amazonaws.cloudsearch#InvalidTypeException":
-            throw await deserializeAws_queryInvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cloudsearch#ValidationException":
-            throw await deserializeAws_queryValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -763,20 +763,20 @@ const deserializeAws_queryDeleteIndexFieldCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_queryDeleteSuggesterCommand = async (output, context) => {
+export const de_DeleteSuggesterCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteSuggesterCommandError(output, context);
+        return de_DeleteSuggesterCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDeleteSuggesterResponse(data.DeleteSuggesterResult, context);
+    contents = de_DeleteSuggesterResponse(data.DeleteSuggesterResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDeleteSuggesterCommandError = async (output, context) => {
+const de_DeleteSuggesterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -785,19 +785,19 @@ const deserializeAws_queryDeleteSuggesterCommandError = async (output, context)
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidType":
         case "com.amazonaws.cloudsearch#InvalidTypeException":
-            throw await deserializeAws_queryInvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cloudsearch#ValidationException":
-            throw await deserializeAws_queryValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -808,20 +808,20 @@ const deserializeAws_queryDeleteSuggesterCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_queryDescribeAnalysisSchemesCommand = async (output, context) => {
+export const de_DescribeAnalysisSchemesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeAnalysisSchemesCommandError(output, context);
+        return de_DescribeAnalysisSchemesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeAnalysisSchemesResponse(data.DescribeAnalysisSchemesResult, context);
+    contents = de_DescribeAnalysisSchemesResponse(data.DescribeAnalysisSchemesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeAnalysisSchemesCommandError = async (output, context) => {
+const de_DescribeAnalysisSchemesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -830,13 +830,13 @@ const deserializeAws_queryDescribeAnalysisSchemesCommandError = async (output, c
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -847,20 +847,20 @@ const deserializeAws_queryDescribeAnalysisSchemesCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_queryDescribeAvailabilityOptionsCommand = async (output, context) => {
+export const de_DescribeAvailabilityOptionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeAvailabilityOptionsCommandError(output, context);
+        return de_DescribeAvailabilityOptionsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeAvailabilityOptionsResponse(data.DescribeAvailabilityOptionsResult, context);
+    contents = de_DescribeAvailabilityOptionsResponse(data.DescribeAvailabilityOptionsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeAvailabilityOptionsCommandError = async (output, context) => {
+const de_DescribeAvailabilityOptionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -869,22 +869,22 @@ const deserializeAws_queryDescribeAvailabilityOptionsCommandError = async (outpu
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "DisabledAction":
         case "com.amazonaws.cloudsearch#DisabledOperationException":
-            throw await deserializeAws_queryDisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidType":
         case "com.amazonaws.cloudsearch#InvalidTypeException":
-            throw await deserializeAws_queryInvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "LimitExceeded":
         case "com.amazonaws.cloudsearch#LimitExceededException":
-            throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -895,20 +895,20 @@ const deserializeAws_queryDescribeAvailabilityOptionsCommandError = async (outpu
             });
     }
 };
-export const deserializeAws_queryDescribeDomainEndpointOptionsCommand = async (output, context) => {
+export const de_DescribeDomainEndpointOptionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeDomainEndpointOptionsCommandError(output, context);
+        return de_DescribeDomainEndpointOptionsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeDomainEndpointOptionsResponse(data.DescribeDomainEndpointOptionsResult, context);
+    contents = de_DescribeDomainEndpointOptionsResponse(data.DescribeDomainEndpointOptionsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeDomainEndpointOptionsCommandError = async (output, context) => {
+const de_DescribeDomainEndpointOptionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -917,19 +917,19 @@ const deserializeAws_queryDescribeDomainEndpointOptionsCommandError = async (out
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "DisabledAction":
         case "com.amazonaws.cloudsearch#DisabledOperationException":
-            throw await deserializeAws_queryDisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "LimitExceeded":
         case "com.amazonaws.cloudsearch#LimitExceededException":
-            throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -940,20 +940,20 @@ const deserializeAws_queryDescribeDomainEndpointOptionsCommandError = async (out
             });
     }
 };
-export const deserializeAws_queryDescribeDomainsCommand = async (output, context) => {
+export const de_DescribeDomainsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeDomainsCommandError(output, context);
+        return de_DescribeDomainsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeDomainsResponse(data.DescribeDomainsResult, context);
+    contents = de_DescribeDomainsResponse(data.DescribeDomainsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeDomainsCommandError = async (output, context) => {
+const de_DescribeDomainsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -962,10 +962,10 @@ const deserializeAws_queryDescribeDomainsCommandError = async (output, context)
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -976,20 +976,20 @@ const deserializeAws_queryDescribeDomainsCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_queryDescribeExpressionsCommand = async (output, context) => {
+export const de_DescribeExpressionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeExpressionsCommandError(output, context);
+        return de_DescribeExpressionsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeExpressionsResponse(data.DescribeExpressionsResult, context);
+    contents = de_DescribeExpressionsResponse(data.DescribeExpressionsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeExpressionsCommandError = async (output, context) => {
+const de_DescribeExpressionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -998,13 +998,13 @@ const deserializeAws_queryDescribeExpressionsCommandError = async (output, conte
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1015,20 +1015,20 @@ const deserializeAws_queryDescribeExpressionsCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_queryDescribeIndexFieldsCommand = async (output, context) => {
+export const de_DescribeIndexFieldsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeIndexFieldsCommandError(output, context);
+        return de_DescribeIndexFieldsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeIndexFieldsResponse(data.DescribeIndexFieldsResult, context);
+    contents = de_DescribeIndexFieldsResponse(data.DescribeIndexFieldsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeIndexFieldsCommandError = async (output, context) => {
+const de_DescribeIndexFieldsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1037,13 +1037,13 @@ const deserializeAws_queryDescribeIndexFieldsCommandError = async (output, conte
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1054,20 +1054,20 @@ const deserializeAws_queryDescribeIndexFieldsCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_queryDescribeScalingParametersCommand = async (output, context) => {
+export const de_DescribeScalingParametersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeScalingParametersCommandError(output, context);
+        return de_DescribeScalingParametersCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeScalingParametersResponse(data.DescribeScalingParametersResult, context);
+    contents = de_DescribeScalingParametersResponse(data.DescribeScalingParametersResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeScalingParametersCommandError = async (output, context) => {
+const de_DescribeScalingParametersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1076,13 +1076,13 @@ const deserializeAws_queryDescribeScalingParametersCommandError = async (output,
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1093,20 +1093,20 @@ const deserializeAws_queryDescribeScalingParametersCommandError = async (output,
             });
     }
 };
-export const deserializeAws_queryDescribeServiceAccessPoliciesCommand = async (output, context) => {
+export const de_DescribeServiceAccessPoliciesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeServiceAccessPoliciesCommandError(output, context);
+        return de_DescribeServiceAccessPoliciesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeServiceAccessPoliciesResponse(data.DescribeServiceAccessPoliciesResult, context);
+    contents = de_DescribeServiceAccessPoliciesResponse(data.DescribeServiceAccessPoliciesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeServiceAccessPoliciesCommandError = async (output, context) => {
+const de_DescribeServiceAccessPoliciesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1115,13 +1115,13 @@ const deserializeAws_queryDescribeServiceAccessPoliciesCommandError = async (out
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1132,20 +1132,20 @@ const deserializeAws_queryDescribeServiceAccessPoliciesCommandError = async (out
             });
     }
 };
-export const deserializeAws_queryDescribeSuggestersCommand = async (output, context) => {
+export const de_DescribeSuggestersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeSuggestersCommandError(output, context);
+        return de_DescribeSuggestersCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeSuggestersResponse(data.DescribeSuggestersResult, context);
+    contents = de_DescribeSuggestersResponse(data.DescribeSuggestersResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeSuggestersCommandError = async (output, context) => {
+const de_DescribeSuggestersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1154,13 +1154,13 @@ const deserializeAws_queryDescribeSuggestersCommandError = async (output, contex
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1171,20 +1171,20 @@ const deserializeAws_queryDescribeSuggestersCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_queryIndexDocumentsCommand = async (output, context) => {
+export const de_IndexDocumentsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryIndexDocumentsCommandError(output, context);
+        return de_IndexDocumentsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryIndexDocumentsResponse(data.IndexDocumentsResult, context);
+    contents = de_IndexDocumentsResponse(data.IndexDocumentsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryIndexDocumentsCommandError = async (output, context) => {
+const de_IndexDocumentsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1193,16 +1193,16 @@ const deserializeAws_queryIndexDocumentsCommandError = async (output, context) =
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cloudsearch#ValidationException":
-            throw await deserializeAws_queryValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1213,20 +1213,20 @@ const deserializeAws_queryIndexDocumentsCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_queryListDomainNamesCommand = async (output, context) => {
+export const de_ListDomainNamesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryListDomainNamesCommandError(output, context);
+        return de_ListDomainNamesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryListDomainNamesResponse(data.ListDomainNamesResult, context);
+    contents = de_ListDomainNamesResponse(data.ListDomainNamesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryListDomainNamesCommandError = async (output, context) => {
+const de_ListDomainNamesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1235,7 +1235,7 @@ const deserializeAws_queryListDomainNamesCommandError = async (output, context)
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1246,20 +1246,20 @@ const deserializeAws_queryListDomainNamesCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_queryUpdateAvailabilityOptionsCommand = async (output, context) => {
+export const de_UpdateAvailabilityOptionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryUpdateAvailabilityOptionsCommandError(output, context);
+        return de_UpdateAvailabilityOptionsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryUpdateAvailabilityOptionsResponse(data.UpdateAvailabilityOptionsResult, context);
+    contents = de_UpdateAvailabilityOptionsResponse(data.UpdateAvailabilityOptionsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryUpdateAvailabilityOptionsCommandError = async (output, context) => {
+const de_UpdateAvailabilityOptionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1268,25 +1268,25 @@ const deserializeAws_queryUpdateAvailabilityOptionsCommandError = async (output,
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "DisabledAction":
         case "com.amazonaws.cloudsearch#DisabledOperationException":
-            throw await deserializeAws_queryDisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidType":
         case "com.amazonaws.cloudsearch#InvalidTypeException":
-            throw await deserializeAws_queryInvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "LimitExceeded":
         case "com.amazonaws.cloudsearch#LimitExceededException":
-            throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cloudsearch#ValidationException":
-            throw await deserializeAws_queryValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1297,20 +1297,20 @@ const deserializeAws_queryUpdateAvailabilityOptionsCommandError = async (output,
             });
     }
 };
-export const deserializeAws_queryUpdateDomainEndpointOptionsCommand = async (output, context) => {
+export const de_UpdateDomainEndpointOptionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryUpdateDomainEndpointOptionsCommandError(output, context);
+        return de_UpdateDomainEndpointOptionsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryUpdateDomainEndpointOptionsResponse(data.UpdateDomainEndpointOptionsResult, context);
+    contents = de_UpdateDomainEndpointOptionsResponse(data.UpdateDomainEndpointOptionsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryUpdateDomainEndpointOptionsCommandError = async (output, context) => {
+const de_UpdateDomainEndpointOptionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1319,25 +1319,25 @@ const deserializeAws_queryUpdateDomainEndpointOptionsCommandError = async (outpu
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "DisabledAction":
         case "com.amazonaws.cloudsearch#DisabledOperationException":
-            throw await deserializeAws_queryDisabledOperationExceptionResponse(parsedOutput, context);
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidType":
         case "com.amazonaws.cloudsearch#InvalidTypeException":
-            throw await deserializeAws_queryInvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "LimitExceeded":
         case "com.amazonaws.cloudsearch#LimitExceededException":
-            throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cloudsearch#ValidationException":
-            throw await deserializeAws_queryValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1348,20 +1348,20 @@ const deserializeAws_queryUpdateDomainEndpointOptionsCommandError = async (outpu
             });
     }
 };
-export const deserializeAws_queryUpdateScalingParametersCommand = async (output, context) => {
+export const de_UpdateScalingParametersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryUpdateScalingParametersCommandError(output, context);
+        return de_UpdateScalingParametersCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryUpdateScalingParametersResponse(data.UpdateScalingParametersResult, context);
+    contents = de_UpdateScalingParametersResponse(data.UpdateScalingParametersResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryUpdateScalingParametersCommandError = async (output, context) => {
+const de_UpdateScalingParametersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1370,22 +1370,22 @@ const deserializeAws_queryUpdateScalingParametersCommandError = async (output, c
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidType":
         case "com.amazonaws.cloudsearch#InvalidTypeException":
-            throw await deserializeAws_queryInvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "LimitExceeded":
         case "com.amazonaws.cloudsearch#LimitExceededException":
-            throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cloudsearch#ValidationException":
-            throw await deserializeAws_queryValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1396,20 +1396,20 @@ const deserializeAws_queryUpdateScalingParametersCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_queryUpdateServiceAccessPoliciesCommand = async (output, context) => {
+export const de_UpdateServiceAccessPoliciesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryUpdateServiceAccessPoliciesCommandError(output, context);
+        return de_UpdateServiceAccessPoliciesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryUpdateServiceAccessPoliciesResponse(data.UpdateServiceAccessPoliciesResult, context);
+    contents = de_UpdateServiceAccessPoliciesResponse(data.UpdateServiceAccessPoliciesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryUpdateServiceAccessPoliciesCommandError = async (output, context) => {
+const de_UpdateServiceAccessPoliciesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1418,22 +1418,22 @@ const deserializeAws_queryUpdateServiceAccessPoliciesCommandError = async (outpu
     switch (errorCode) {
         case "BaseException":
         case "com.amazonaws.cloudsearch#BaseException":
-            throw await deserializeAws_queryBaseExceptionResponse(parsedOutput, context);
+            throw await de_BaseExceptionRes(parsedOutput, context);
         case "InternalException":
         case "com.amazonaws.cloudsearch#InternalException":
-            throw await deserializeAws_queryInternalExceptionResponse(parsedOutput, context);
+            throw await de_InternalExceptionRes(parsedOutput, context);
         case "InvalidType":
         case "com.amazonaws.cloudsearch#InvalidTypeException":
-            throw await deserializeAws_queryInvalidTypeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTypeExceptionRes(parsedOutput, context);
         case "LimitExceeded":
         case "com.amazonaws.cloudsearch#LimitExceededException":
-            throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFound":
         case "com.amazonaws.cloudsearch#ResourceNotFoundException":
-            throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cloudsearch#ValidationException":
-            throw await deserializeAws_queryValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1444,79 +1444,79 @@ const deserializeAws_queryUpdateServiceAccessPoliciesCommandError = async (outpu
             });
     }
 };
-const deserializeAws_queryBaseExceptionResponse = async (parsedOutput, context) => {
+const de_BaseExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryBaseException(body.Error, context);
+    const deserialized = de_BaseException(body.Error, context);
     const exception = new BaseException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryDisabledOperationExceptionResponse = async (parsedOutput, context) => {
+const de_DisabledOperationExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryDisabledOperationException(body.Error, context);
+    const deserialized = de_DisabledOperationException(body.Error, context);
     const exception = new DisabledOperationException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryInternalExceptionResponse = async (parsedOutput, context) => {
+const de_InternalExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInternalException(body.Error, context);
+    const deserialized = de_InternalException(body.Error, context);
     const exception = new InternalException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryInvalidTypeExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidTypeExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidTypeException(body.Error, context);
+    const deserialized = de_InvalidTypeException(body.Error, context);
     const exception = new InvalidTypeException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryLimitExceededExceptionResponse = async (parsedOutput, context) => {
+const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryLimitExceededException(body.Error, context);
+    const deserialized = de_LimitExceededException(body.Error, context);
     const exception = new LimitExceededException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryResourceAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceAlreadyExistsExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryResourceAlreadyExistsException(body.Error, context);
+    const deserialized = de_ResourceAlreadyExistsException(body.Error, context);
     const exception = new ResourceAlreadyExistsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryResourceNotFoundException(body.Error, context);
+    const deserialized = de_ResourceNotFoundException(body.Error, context);
     const exception = new ResourceNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryValidationExceptionResponse = async (parsedOutput, context) => {
+const de_ValidationExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryValidationException(body.Error, context);
+    const deserialized = de_ValidationException(body.Error, context);
     const exception = new ValidationException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const serializeAws_queryAnalysisOptions = (input, context) => {
+const se_AnalysisOptions = (input, context) => {
     const entries = {};
     if (input.Synonyms != null) {
         entries["Synonyms"] = input.Synonyms;
@@ -1535,7 +1535,7 @@ const serializeAws_queryAnalysisOptions = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryAnalysisScheme = (input, context) => {
+const se_AnalysisScheme = (input, context) => {
     const entries = {};
     if (input.AnalysisSchemeName != null) {
         entries["AnalysisSchemeName"] = input.AnalysisSchemeName;
@@ -1544,7 +1544,7 @@ const serializeAws_queryAnalysisScheme = (input, context) => {
         entries["AnalysisSchemeLanguage"] = input.AnalysisSchemeLanguage;
     }
     if (input.AnalysisOptions != null) {
-        const memberEntries = serializeAws_queryAnalysisOptions(input.AnalysisOptions, context);
+        const memberEntries = se_AnalysisOptions(input.AnalysisOptions, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `AnalysisOptions.${key}`;
             entries[loc] = value;
@@ -1552,21 +1552,21 @@ const serializeAws_queryAnalysisScheme = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryBuildSuggestersRequest = (input, context) => {
+const se_BuildSuggestersRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
     }
     return entries;
 };
-const serializeAws_queryCreateDomainRequest = (input, context) => {
+const se_CreateDomainRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
     }
     return entries;
 };
-const serializeAws_queryDateArrayOptions = (input, context) => {
+const se_DateArrayOptions = (input, context) => {
     const entries = {};
     if (input.DefaultValue != null) {
         entries["DefaultValue"] = input.DefaultValue;
@@ -1585,7 +1585,7 @@ const serializeAws_queryDateArrayOptions = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDateOptions = (input, context) => {
+const se_DateOptions = (input, context) => {
     const entries = {};
     if (input.DefaultValue != null) {
         entries["DefaultValue"] = input.DefaultValue;
@@ -1607,13 +1607,13 @@ const serializeAws_queryDateOptions = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDefineAnalysisSchemeRequest = (input, context) => {
+const se_DefineAnalysisSchemeRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
     }
     if (input.AnalysisScheme != null) {
-        const memberEntries = serializeAws_queryAnalysisScheme(input.AnalysisScheme, context);
+        const memberEntries = se_AnalysisScheme(input.AnalysisScheme, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `AnalysisScheme.${key}`;
             entries[loc] = value;
@@ -1621,13 +1621,13 @@ const serializeAws_queryDefineAnalysisSchemeRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDefineExpressionRequest = (input, context) => {
+const se_DefineExpressionRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
     }
     if (input.Expression != null) {
-        const memberEntries = serializeAws_queryExpression(input.Expression, context);
+        const memberEntries = se_Expression(input.Expression, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `Expression.${key}`;
             entries[loc] = value;
@@ -1635,13 +1635,13 @@ const serializeAws_queryDefineExpressionRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDefineIndexFieldRequest = (input, context) => {
+const se_DefineIndexFieldRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
     }
     if (input.IndexField != null) {
-        const memberEntries = serializeAws_queryIndexField(input.IndexField, context);
+        const memberEntries = se_IndexField(input.IndexField, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `IndexField.${key}`;
             entries[loc] = value;
@@ -1649,13 +1649,13 @@ const serializeAws_queryDefineIndexFieldRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDefineSuggesterRequest = (input, context) => {
+const se_DefineSuggesterRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
     }
     if (input.Suggester != null) {
-        const memberEntries = serializeAws_querySuggester(input.Suggester, context);
+        const memberEntries = se_Suggester(input.Suggester, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `Suggester.${key}`;
             entries[loc] = value;
@@ -1663,7 +1663,7 @@ const serializeAws_queryDefineSuggesterRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeleteAnalysisSchemeRequest = (input, context) => {
+const se_DeleteAnalysisSchemeRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
@@ -1673,14 +1673,14 @@ const serializeAws_queryDeleteAnalysisSchemeRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeleteDomainRequest = (input, context) => {
+const se_DeleteDomainRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
     }
     return entries;
 };
-const serializeAws_queryDeleteExpressionRequest = (input, context) => {
+const se_DeleteExpressionRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
@@ -1690,7 +1690,7 @@ const serializeAws_queryDeleteExpressionRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeleteIndexFieldRequest = (input, context) => {
+const se_DeleteIndexFieldRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
@@ -1700,7 +1700,7 @@ const serializeAws_queryDeleteIndexFieldRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeleteSuggesterRequest = (input, context) => {
+const se_DeleteSuggesterRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
@@ -1710,13 +1710,13 @@ const serializeAws_queryDeleteSuggesterRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDescribeAnalysisSchemesRequest = (input, context) => {
+const se_DescribeAnalysisSchemesRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
     }
     if (input.AnalysisSchemeNames != null) {
-        const memberEntries = serializeAws_queryStandardNameList(input.AnalysisSchemeNames, context);
+        const memberEntries = se_StandardNameList(input.AnalysisSchemeNames, context);
         if (input.AnalysisSchemeNames?.length === 0) {
             entries.AnalysisSchemeNames = [];
         }
@@ -1730,7 +1730,7 @@ const serializeAws_queryDescribeAnalysisSchemesRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDescribeAvailabilityOptionsRequest = (input, context) => {
+const se_DescribeAvailabilityOptionsRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
@@ -1740,7 +1740,7 @@ const serializeAws_queryDescribeAvailabilityOptionsRequest = (input, context) =>
     }
     return entries;
 };
-const serializeAws_queryDescribeDomainEndpointOptionsRequest = (input, context) => {
+const se_DescribeDomainEndpointOptionsRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
@@ -1750,10 +1750,10 @@ const serializeAws_queryDescribeDomainEndpointOptionsRequest = (input, context)
     }
     return entries;
 };
-const serializeAws_queryDescribeDomainsRequest = (input, context) => {
+const se_DescribeDomainsRequest = (input, context) => {
     const entries = {};
     if (input.DomainNames != null) {
-        const memberEntries = serializeAws_queryDomainNameList(input.DomainNames, context);
+        const memberEntries = se_DomainNameList(input.DomainNames, context);
         if (input.DomainNames?.length === 0) {
             entries.DomainNames = [];
         }
@@ -1764,13 +1764,13 @@ const serializeAws_queryDescribeDomainsRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDescribeExpressionsRequest = (input, context) => {
+const se_DescribeExpressionsRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
     }
     if (input.ExpressionNames != null) {
-        const memberEntries = serializeAws_queryStandardNameList(input.ExpressionNames, context);
+        const memberEntries = se_StandardNameList(input.ExpressionNames, context);
         if (input.ExpressionNames?.length === 0) {
             entries.ExpressionNames = [];
         }
@@ -1784,13 +1784,13 @@ const serializeAws_queryDescribeExpressionsRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDescribeIndexFieldsRequest = (input, context) => {
+const se_DescribeIndexFieldsRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
     }
     if (input.FieldNames != null) {
-        const memberEntries = serializeAws_queryDynamicFieldNameList(input.FieldNames, context);
+        const memberEntries = se_DynamicFieldNameList(input.FieldNames, context);
         if (input.FieldNames?.length === 0) {
             entries.FieldNames = [];
         }
@@ -1804,14 +1804,14 @@ const serializeAws_queryDescribeIndexFieldsRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDescribeScalingParametersRequest = (input, context) => {
+const se_DescribeScalingParametersRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
     }
     return entries;
 };
-const serializeAws_queryDescribeServiceAccessPoliciesRequest = (input, context) => {
+const se_DescribeServiceAccessPoliciesRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
@@ -1821,13 +1821,13 @@ const serializeAws_queryDescribeServiceAccessPoliciesRequest = (input, context)
     }
     return entries;
 };
-const serializeAws_queryDescribeSuggestersRequest = (input, context) => {
+const se_DescribeSuggestersRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
     }
     if (input.SuggesterNames != null) {
-        const memberEntries = serializeAws_queryStandardNameList(input.SuggesterNames, context);
+        const memberEntries = se_StandardNameList(input.SuggesterNames, context);
         if (input.SuggesterNames?.length === 0) {
             entries.SuggesterNames = [];
         }
@@ -1841,7 +1841,7 @@ const serializeAws_queryDescribeSuggestersRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDocumentSuggesterOptions = (input, context) => {
+const se_DocumentSuggesterOptions = (input, context) => {
     const entries = {};
     if (input.SourceField != null) {
         entries["SourceField"] = input.SourceField;
@@ -1854,7 +1854,7 @@ const serializeAws_queryDocumentSuggesterOptions = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDomainEndpointOptions = (input, context) => {
+const se_DomainEndpointOptions = (input, context) => {
     const entries = {};
     if (input.EnforceHTTPS != null) {
         entries["EnforceHTTPS"] = input.EnforceHTTPS;
@@ -1864,7 +1864,7 @@ const serializeAws_queryDomainEndpointOptions = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDomainNameList = (input, context) => {
+const se_DomainNameList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -1876,7 +1876,7 @@ const serializeAws_queryDomainNameList = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDoubleArrayOptions = (input, context) => {
+const se_DoubleArrayOptions = (input, context) => {
     const entries = {};
     if (input.DefaultValue != null) {
         entries["DefaultValue"] = __serializeFloat(input.DefaultValue);
@@ -1895,7 +1895,7 @@ const serializeAws_queryDoubleArrayOptions = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDoubleOptions = (input, context) => {
+const se_DoubleOptions = (input, context) => {
     const entries = {};
     if (input.DefaultValue != null) {
         entries["DefaultValue"] = __serializeFloat(input.DefaultValue);
@@ -1917,7 +1917,7 @@ const serializeAws_queryDoubleOptions = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDynamicFieldNameList = (input, context) => {
+const se_DynamicFieldNameList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -1929,7 +1929,7 @@ const serializeAws_queryDynamicFieldNameList = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryExpression = (input, context) => {
+const se_Expression = (input, context) => {
     const entries = {};
     if (input.ExpressionName != null) {
         entries["ExpressionName"] = input.ExpressionName;
@@ -1939,14 +1939,14 @@ const serializeAws_queryExpression = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryIndexDocumentsRequest = (input, context) => {
+const se_IndexDocumentsRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
     }
     return entries;
 };
-const serializeAws_queryIndexField = (input, context) => {
+const se_IndexField = (input, context) => {
     const entries = {};
     if (input.IndexFieldName != null) {
         entries["IndexFieldName"] = input.IndexFieldName;
@@ -1955,77 +1955,77 @@ const serializeAws_queryIndexField = (input, context) => {
         entries["IndexFieldType"] = input.IndexFieldType;
     }
     if (input.IntOptions != null) {
-        const memberEntries = serializeAws_queryIntOptions(input.IntOptions, context);
+        const memberEntries = se_IntOptions(input.IntOptions, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `IntOptions.${key}`;
             entries[loc] = value;
         });
     }
     if (input.DoubleOptions != null) {
-        const memberEntries = serializeAws_queryDoubleOptions(input.DoubleOptions, context);
+        const memberEntries = se_DoubleOptions(input.DoubleOptions, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `DoubleOptions.${key}`;
             entries[loc] = value;
         });
     }
     if (input.LiteralOptions != null) {
-        const memberEntries = serializeAws_queryLiteralOptions(input.LiteralOptions, context);
+        const memberEntries = se_LiteralOptions(input.LiteralOptions, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `LiteralOptions.${key}`;
             entries[loc] = value;
         });
     }
     if (input.TextOptions != null) {
-        const memberEntries = serializeAws_queryTextOptions(input.TextOptions, context);
+        const memberEntries = se_TextOptions(input.TextOptions, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `TextOptions.${key}`;
             entries[loc] = value;
         });
     }
     if (input.DateOptions != null) {
-        const memberEntries = serializeAws_queryDateOptions(input.DateOptions, context);
+        const memberEntries = se_DateOptions(input.DateOptions, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `DateOptions.${key}`;
             entries[loc] = value;
         });
     }
     if (input.LatLonOptions != null) {
-        const memberEntries = serializeAws_queryLatLonOptions(input.LatLonOptions, context);
+        const memberEntries = se_LatLonOptions(input.LatLonOptions, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `LatLonOptions.${key}`;
             entries[loc] = value;
         });
     }
     if (input.IntArrayOptions != null) {
-        const memberEntries = serializeAws_queryIntArrayOptions(input.IntArrayOptions, context);
+        const memberEntries = se_IntArrayOptions(input.IntArrayOptions, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `IntArrayOptions.${key}`;
             entries[loc] = value;
         });
     }
     if (input.DoubleArrayOptions != null) {
-        const memberEntries = serializeAws_queryDoubleArrayOptions(input.DoubleArrayOptions, context);
+        const memberEntries = se_DoubleArrayOptions(input.DoubleArrayOptions, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `DoubleArrayOptions.${key}`;
             entries[loc] = value;
         });
     }
     if (input.LiteralArrayOptions != null) {
-        const memberEntries = serializeAws_queryLiteralArrayOptions(input.LiteralArrayOptions, context);
+        const memberEntries = se_LiteralArrayOptions(input.LiteralArrayOptions, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `LiteralArrayOptions.${key}`;
             entries[loc] = value;
         });
     }
     if (input.TextArrayOptions != null) {
-        const memberEntries = serializeAws_queryTextArrayOptions(input.TextArrayOptions, context);
+        const memberEntries = se_TextArrayOptions(input.TextArrayOptions, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `TextArrayOptions.${key}`;
             entries[loc] = value;
         });
     }
     if (input.DateArrayOptions != null) {
-        const memberEntries = serializeAws_queryDateArrayOptions(input.DateArrayOptions, context);
+        const memberEntries = se_DateArrayOptions(input.DateArrayOptions, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `DateArrayOptions.${key}`;
             entries[loc] = value;
@@ -2033,7 +2033,7 @@ const serializeAws_queryIndexField = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryIntArrayOptions = (input, context) => {
+const se_IntArrayOptions = (input, context) => {
     const entries = {};
     if (input.DefaultValue != null) {
         entries["DefaultValue"] = input.DefaultValue;
@@ -2052,7 +2052,7 @@ const serializeAws_queryIntArrayOptions = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryIntOptions = (input, context) => {
+const se_IntOptions = (input, context) => {
     const entries = {};
     if (input.DefaultValue != null) {
         entries["DefaultValue"] = input.DefaultValue;
@@ -2074,7 +2074,7 @@ const serializeAws_queryIntOptions = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryLatLonOptions = (input, context) => {
+const se_LatLonOptions = (input, context) => {
     const entries = {};
     if (input.DefaultValue != null) {
         entries["DefaultValue"] = input.DefaultValue;
@@ -2096,7 +2096,7 @@ const serializeAws_queryLatLonOptions = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryLiteralArrayOptions = (input, context) => {
+const se_LiteralArrayOptions = (input, context) => {
     const entries = {};
     if (input.DefaultValue != null) {
         entries["DefaultValue"] = input.DefaultValue;
@@ -2115,7 +2115,7 @@ const serializeAws_queryLiteralArrayOptions = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryLiteralOptions = (input, context) => {
+const se_LiteralOptions = (input, context) => {
     const entries = {};
     if (input.DefaultValue != null) {
         entries["DefaultValue"] = input.DefaultValue;
@@ -2137,7 +2137,7 @@ const serializeAws_queryLiteralOptions = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryScalingParameters = (input, context) => {
+const se_ScalingParameters = (input, context) => {
     const entries = {};
     if (input.DesiredInstanceType != null) {
         entries["DesiredInstanceType"] = input.DesiredInstanceType;
@@ -2150,7 +2150,7 @@ const serializeAws_queryScalingParameters = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryStandardNameList = (input, context) => {
+const se_StandardNameList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -2162,13 +2162,13 @@ const serializeAws_queryStandardNameList = (input, context) => {
     }
     return entries;
 };
-const serializeAws_querySuggester = (input, context) => {
+const se_Suggester = (input, context) => {
     const entries = {};
     if (input.SuggesterName != null) {
         entries["SuggesterName"] = input.SuggesterName;
     }
     if (input.DocumentSuggesterOptions != null) {
-        const memberEntries = serializeAws_queryDocumentSuggesterOptions(input.DocumentSuggesterOptions, context);
+        const memberEntries = se_DocumentSuggesterOptions(input.DocumentSuggesterOptions, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `DocumentSuggesterOptions.${key}`;
             entries[loc] = value;
@@ -2176,7 +2176,7 @@ const serializeAws_querySuggester = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryTextArrayOptions = (input, context) => {
+const se_TextArrayOptions = (input, context) => {
     const entries = {};
     if (input.DefaultValue != null) {
         entries["DefaultValue"] = input.DefaultValue;
@@ -2195,7 +2195,7 @@ const serializeAws_queryTextArrayOptions = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryTextOptions = (input, context) => {
+const se_TextOptions = (input, context) => {
     const entries = {};
     if (input.DefaultValue != null) {
         entries["DefaultValue"] = input.DefaultValue;
@@ -2217,7 +2217,7 @@ const serializeAws_queryTextOptions = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryUpdateAvailabilityOptionsRequest = (input, context) => {
+const se_UpdateAvailabilityOptionsRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
@@ -2227,13 +2227,13 @@ const serializeAws_queryUpdateAvailabilityOptionsRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryUpdateDomainEndpointOptionsRequest = (input, context) => {
+const se_UpdateDomainEndpointOptionsRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
     }
     if (input.DomainEndpointOptions != null) {
-        const memberEntries = serializeAws_queryDomainEndpointOptions(input.DomainEndpointOptions, context);
+        const memberEntries = se_DomainEndpointOptions(input.DomainEndpointOptions, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `DomainEndpointOptions.${key}`;
             entries[loc] = value;
@@ -2241,13 +2241,13 @@ const serializeAws_queryUpdateDomainEndpointOptionsRequest = (input, context) =>
     }
     return entries;
 };
-const serializeAws_queryUpdateScalingParametersRequest = (input, context) => {
+const se_UpdateScalingParametersRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
     }
     if (input.ScalingParameters != null) {
-        const memberEntries = serializeAws_queryScalingParameters(input.ScalingParameters, context);
+        const memberEntries = se_ScalingParameters(input.ScalingParameters, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `ScalingParameters.${key}`;
             entries[loc] = value;
@@ -2255,7 +2255,7 @@ const serializeAws_queryUpdateScalingParametersRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryUpdateServiceAccessPoliciesRequest = (input, context) => {
+const se_UpdateServiceAccessPoliciesRequest = (input, context) => {
     const entries = {};
     if (input.DomainName != null) {
         entries["DomainName"] = input.DomainName;
@@ -2265,17 +2265,17 @@ const serializeAws_queryUpdateServiceAccessPoliciesRequest = (input, context) =>
     }
     return entries;
 };
-const deserializeAws_queryAccessPoliciesStatus = (output, context) => {
+const de_AccessPoliciesStatus = (output, context) => {
     const contents = {};
     if (output["Options"] !== undefined) {
         contents.Options = __expectString(output["Options"]);
     }
     if (output["Status"] !== undefined) {
-        contents.Status = deserializeAws_queryOptionStatus(output["Status"], context);
+        contents.Status = de_OptionStatus(output["Status"], context);
     }
     return contents;
 };
-const deserializeAws_queryAnalysisOptions = (output, context) => {
+const de_AnalysisOptions = (output, context) => {
     const contents = {};
     if (output["Synonyms"] !== undefined) {
         contents.Synonyms = __expectString(output["Synonyms"]);
@@ -2294,7 +2294,7 @@ const deserializeAws_queryAnalysisOptions = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryAnalysisScheme = (output, context) => {
+const de_AnalysisScheme = (output, context) => {
     const contents = {};
     if (output["AnalysisSchemeName"] !== undefined) {
         contents.AnalysisSchemeName = __expectString(output["AnalysisSchemeName"]);
@@ -2303,38 +2303,38 @@ const deserializeAws_queryAnalysisScheme = (output, context) => {
         contents.AnalysisSchemeLanguage = __expectString(output["AnalysisSchemeLanguage"]);
     }
     if (output["AnalysisOptions"] !== undefined) {
-        contents.AnalysisOptions = deserializeAws_queryAnalysisOptions(output["AnalysisOptions"], context);
+        contents.AnalysisOptions = de_AnalysisOptions(output["AnalysisOptions"], context);
     }
     return contents;
 };
-const deserializeAws_queryAnalysisSchemeStatus = (output, context) => {
+const de_AnalysisSchemeStatus = (output, context) => {
     const contents = {};
     if (output["Options"] !== undefined) {
-        contents.Options = deserializeAws_queryAnalysisScheme(output["Options"], context);
+        contents.Options = de_AnalysisScheme(output["Options"], context);
     }
     if (output["Status"] !== undefined) {
-        contents.Status = deserializeAws_queryOptionStatus(output["Status"], context);
+        contents.Status = de_OptionStatus(output["Status"], context);
     }
     return contents;
 };
-const deserializeAws_queryAnalysisSchemeStatusList = (output, context) => {
+const de_AnalysisSchemeStatusList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryAnalysisSchemeStatus(entry, context);
+        return de_AnalysisSchemeStatus(entry, context);
     });
 };
-const deserializeAws_queryAvailabilityOptionsStatus = (output, context) => {
+const de_AvailabilityOptionsStatus = (output, context) => {
     const contents = {};
     if (output["Options"] !== undefined) {
         contents.Options = __parseBoolean(output["Options"]);
     }
     if (output["Status"] !== undefined) {
-        contents.Status = deserializeAws_queryOptionStatus(output["Status"], context);
+        contents.Status = de_OptionStatus(output["Status"], context);
     }
     return contents;
 };
-const deserializeAws_queryBaseException = (output, context) => {
+const de_BaseException = (output, context) => {
     const contents = {};
     if (output["Code"] !== undefined) {
         contents.Code = __expectString(output["Code"]);
@@ -2344,24 +2344,24 @@ const deserializeAws_queryBaseException = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryBuildSuggestersResponse = (output, context) => {
+const de_BuildSuggestersResponse = (output, context) => {
     const contents = {};
     if (output.FieldNames === "") {
         contents.FieldNames = [];
     }
     else if (output["FieldNames"] !== undefined && output["FieldNames"]["member"] !== undefined) {
-        contents.FieldNames = deserializeAws_queryFieldNameList(__getArrayIfSingleItem(output["FieldNames"]["member"]), context);
+        contents.FieldNames = de_FieldNameList(__getArrayIfSingleItem(output["FieldNames"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryCreateDomainResponse = (output, context) => {
+const de_CreateDomainResponse = (output, context) => {
     const contents = {};
     if (output["DomainStatus"] !== undefined) {
-        contents.DomainStatus = deserializeAws_queryDomainStatus(output["DomainStatus"], context);
+        contents.DomainStatus = de_DomainStatus(output["DomainStatus"], context);
     }
     return contents;
 };
-const deserializeAws_queryDateArrayOptions = (output, context) => {
+const de_DateArrayOptions = (output, context) => {
     const contents = {};
     if (output["DefaultValue"] !== undefined) {
         contents.DefaultValue = __expectString(output["DefaultValue"]);
@@ -2380,7 +2380,7 @@ const deserializeAws_queryDateArrayOptions = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryDateOptions = (output, context) => {
+const de_DateOptions = (output, context) => {
     const contents = {};
     if (output["DefaultValue"] !== undefined) {
         contents.DefaultValue = __expectString(output["DefaultValue"]);
@@ -2402,148 +2402,148 @@ const deserializeAws_queryDateOptions = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryDefineAnalysisSchemeResponse = (output, context) => {
+const de_DefineAnalysisSchemeResponse = (output, context) => {
     const contents = {};
     if (output["AnalysisScheme"] !== undefined) {
-        contents.AnalysisScheme = deserializeAws_queryAnalysisSchemeStatus(output["AnalysisScheme"], context);
+        contents.AnalysisScheme = de_AnalysisSchemeStatus(output["AnalysisScheme"], context);
     }
     return contents;
 };
-const deserializeAws_queryDefineExpressionResponse = (output, context) => {
+const de_DefineExpressionResponse = (output, context) => {
     const contents = {};
     if (output["Expression"] !== undefined) {
-        contents.Expression = deserializeAws_queryExpressionStatus(output["Expression"], context);
+        contents.Expression = de_ExpressionStatus(output["Expression"], context);
     }
     return contents;
 };
-const deserializeAws_queryDefineIndexFieldResponse = (output, context) => {
+const de_DefineIndexFieldResponse = (output, context) => {
     const contents = {};
     if (output["IndexField"] !== undefined) {
-        contents.IndexField = deserializeAws_queryIndexFieldStatus(output["IndexField"], context);
+        contents.IndexField = de_IndexFieldStatus(output["IndexField"], context);
     }
     return contents;
 };
-const deserializeAws_queryDefineSuggesterResponse = (output, context) => {
+const de_DefineSuggesterResponse = (output, context) => {
     const contents = {};
     if (output["Suggester"] !== undefined) {
-        contents.Suggester = deserializeAws_querySuggesterStatus(output["Suggester"], context);
+        contents.Suggester = de_SuggesterStatus(output["Suggester"], context);
     }
     return contents;
 };
-const deserializeAws_queryDeleteAnalysisSchemeResponse = (output, context) => {
+const de_DeleteAnalysisSchemeResponse = (output, context) => {
     const contents = {};
     if (output["AnalysisScheme"] !== undefined) {
-        contents.AnalysisScheme = deserializeAws_queryAnalysisSchemeStatus(output["AnalysisScheme"], context);
+        contents.AnalysisScheme = de_AnalysisSchemeStatus(output["AnalysisScheme"], context);
     }
     return contents;
 };
-const deserializeAws_queryDeleteDomainResponse = (output, context) => {
+const de_DeleteDomainResponse = (output, context) => {
     const contents = {};
     if (output["DomainStatus"] !== undefined) {
-        contents.DomainStatus = deserializeAws_queryDomainStatus(output["DomainStatus"], context);
+        contents.DomainStatus = de_DomainStatus(output["DomainStatus"], context);
     }
     return contents;
 };
-const deserializeAws_queryDeleteExpressionResponse = (output, context) => {
+const de_DeleteExpressionResponse = (output, context) => {
     const contents = {};
     if (output["Expression"] !== undefined) {
-        contents.Expression = deserializeAws_queryExpressionStatus(output["Expression"], context);
+        contents.Expression = de_ExpressionStatus(output["Expression"], context);
     }
     return contents;
 };
-const deserializeAws_queryDeleteIndexFieldResponse = (output, context) => {
+const de_DeleteIndexFieldResponse = (output, context) => {
     const contents = {};
     if (output["IndexField"] !== undefined) {
-        contents.IndexField = deserializeAws_queryIndexFieldStatus(output["IndexField"], context);
+        contents.IndexField = de_IndexFieldStatus(output["IndexField"], context);
     }
     return contents;
 };
-const deserializeAws_queryDeleteSuggesterResponse = (output, context) => {
+const de_DeleteSuggesterResponse = (output, context) => {
     const contents = {};
     if (output["Suggester"] !== undefined) {
-        contents.Suggester = deserializeAws_querySuggesterStatus(output["Suggester"], context);
+        contents.Suggester = de_SuggesterStatus(output["Suggester"], context);
     }
     return contents;
 };
-const deserializeAws_queryDescribeAnalysisSchemesResponse = (output, context) => {
+const de_DescribeAnalysisSchemesResponse = (output, context) => {
     const contents = {};
     if (output.AnalysisSchemes === "") {
         contents.AnalysisSchemes = [];
     }
     else if (output["AnalysisSchemes"] !== undefined && output["AnalysisSchemes"]["member"] !== undefined) {
-        contents.AnalysisSchemes = deserializeAws_queryAnalysisSchemeStatusList(__getArrayIfSingleItem(output["AnalysisSchemes"]["member"]), context);
+        contents.AnalysisSchemes = de_AnalysisSchemeStatusList(__getArrayIfSingleItem(output["AnalysisSchemes"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDescribeAvailabilityOptionsResponse = (output, context) => {
+const de_DescribeAvailabilityOptionsResponse = (output, context) => {
     const contents = {};
     if (output["AvailabilityOptions"] !== undefined) {
-        contents.AvailabilityOptions = deserializeAws_queryAvailabilityOptionsStatus(output["AvailabilityOptions"], context);
+        contents.AvailabilityOptions = de_AvailabilityOptionsStatus(output["AvailabilityOptions"], context);
     }
     return contents;
 };
-const deserializeAws_queryDescribeDomainEndpointOptionsResponse = (output, context) => {
+const de_DescribeDomainEndpointOptionsResponse = (output, context) => {
     const contents = {};
     if (output["DomainEndpointOptions"] !== undefined) {
-        contents.DomainEndpointOptions = deserializeAws_queryDomainEndpointOptionsStatus(output["DomainEndpointOptions"], context);
+        contents.DomainEndpointOptions = de_DomainEndpointOptionsStatus(output["DomainEndpointOptions"], context);
     }
     return contents;
 };
-const deserializeAws_queryDescribeDomainsResponse = (output, context) => {
+const de_DescribeDomainsResponse = (output, context) => {
     const contents = {};
     if (output.DomainStatusList === "") {
         contents.DomainStatusList = [];
     }
     else if (output["DomainStatusList"] !== undefined && output["DomainStatusList"]["member"] !== undefined) {
-        contents.DomainStatusList = deserializeAws_queryDomainStatusList(__getArrayIfSingleItem(output["DomainStatusList"]["member"]), context);
+        contents.DomainStatusList = de_DomainStatusList(__getArrayIfSingleItem(output["DomainStatusList"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDescribeExpressionsResponse = (output, context) => {
+const de_DescribeExpressionsResponse = (output, context) => {
     const contents = {};
     if (output.Expressions === "") {
         contents.Expressions = [];
     }
     else if (output["Expressions"] !== undefined && output["Expressions"]["member"] !== undefined) {
-        contents.Expressions = deserializeAws_queryExpressionStatusList(__getArrayIfSingleItem(output["Expressions"]["member"]), context);
+        contents.Expressions = de_ExpressionStatusList(__getArrayIfSingleItem(output["Expressions"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDescribeIndexFieldsResponse = (output, context) => {
+const de_DescribeIndexFieldsResponse = (output, context) => {
     const contents = {};
     if (output.IndexFields === "") {
         contents.IndexFields = [];
     }
     else if (output["IndexFields"] !== undefined && output["IndexFields"]["member"] !== undefined) {
-        contents.IndexFields = deserializeAws_queryIndexFieldStatusList(__getArrayIfSingleItem(output["IndexFields"]["member"]), context);
+        contents.IndexFields = de_IndexFieldStatusList(__getArrayIfSingleItem(output["IndexFields"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDescribeScalingParametersResponse = (output, context) => {
+const de_DescribeScalingParametersResponse = (output, context) => {
     const contents = {};
     if (output["ScalingParameters"] !== undefined) {
-        contents.ScalingParameters = deserializeAws_queryScalingParametersStatus(output["ScalingParameters"], context);
+        contents.ScalingParameters = de_ScalingParametersStatus(output["ScalingParameters"], context);
     }
     return contents;
 };
-const deserializeAws_queryDescribeServiceAccessPoliciesResponse = (output, context) => {
+const de_DescribeServiceAccessPoliciesResponse = (output, context) => {
     const contents = {};
     if (output["AccessPolicies"] !== undefined) {
-        contents.AccessPolicies = deserializeAws_queryAccessPoliciesStatus(output["AccessPolicies"], context);
+        contents.AccessPolicies = de_AccessPoliciesStatus(output["AccessPolicies"], context);
     }
     return contents;
 };
-const deserializeAws_queryDescribeSuggestersResponse = (output, context) => {
+const de_DescribeSuggestersResponse = (output, context) => {
     const contents = {};
     if (output.Suggesters === "") {
         contents.Suggesters = [];
     }
     else if (output["Suggesters"] !== undefined && output["Suggesters"]["member"] !== undefined) {
-        contents.Suggesters = deserializeAws_querySuggesterStatusList(__getArrayIfSingleItem(output["Suggesters"]["member"]), context);
+        contents.Suggesters = de_SuggesterStatusList(__getArrayIfSingleItem(output["Suggesters"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDisabledOperationException = (output, context) => {
+const de_DisabledOperationException = (output, context) => {
     const contents = {};
     if (output["Code"] !== undefined) {
         contents.Code = __expectString(output["Code"]);
@@ -2553,7 +2553,7 @@ const deserializeAws_queryDisabledOperationException = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryDocumentSuggesterOptions = (output, context) => {
+const de_DocumentSuggesterOptions = (output, context) => {
     const contents = {};
     if (output["SourceField"] !== undefined) {
         contents.SourceField = __expectString(output["SourceField"]);
@@ -2566,7 +2566,7 @@ const deserializeAws_queryDocumentSuggesterOptions = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryDomainEndpointOptions = (output, context) => {
+const de_DomainEndpointOptions = (output, context) => {
     const contents = {};
     if (output["EnforceHTTPS"] !== undefined) {
         contents.EnforceHTTPS = __parseBoolean(output["EnforceHTTPS"]);
@@ -2576,17 +2576,17 @@ const deserializeAws_queryDomainEndpointOptions = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryDomainEndpointOptionsStatus = (output, context) => {
+const de_DomainEndpointOptionsStatus = (output, context) => {
     const contents = {};
     if (output["Options"] !== undefined) {
-        contents.Options = deserializeAws_queryDomainEndpointOptions(output["Options"], context);
+        contents.Options = de_DomainEndpointOptions(output["Options"], context);
     }
     if (output["Status"] !== undefined) {
-        contents.Status = deserializeAws_queryOptionStatus(output["Status"], context);
+        contents.Status = de_OptionStatus(output["Status"], context);
     }
     return contents;
 };
-const deserializeAws_queryDomainNameMap = (output, context) => {
+const de_DomainNameMap = (output, context) => {
     return output.reduce((acc, pair) => {
         if (pair["value"] === null) {
             return acc;
@@ -2595,7 +2595,7 @@ const deserializeAws_queryDomainNameMap = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_queryDomainStatus = (output, context) => {
+const de_DomainStatus = (output, context) => {
     const contents = {};
     if (output["DomainId"] !== undefined) {
         contents.DomainId = __expectString(output["DomainId"]);
@@ -2613,10 +2613,10 @@ const deserializeAws_queryDomainStatus = (output, context) => {
         contents.Deleted = __parseBoolean(output["Deleted"]);
     }
     if (output["DocService"] !== undefined) {
-        contents.DocService = deserializeAws_queryServiceEndpoint(output["DocService"], context);
+        contents.DocService = de_ServiceEndpoint(output["DocService"], context);
     }
     if (output["SearchService"] !== undefined) {
-        contents.SearchService = deserializeAws_queryServiceEndpoint(output["SearchService"], context);
+        contents.SearchService = de_ServiceEndpoint(output["SearchService"], context);
     }
     if (output["RequiresIndexDocuments"] !== undefined) {
         contents.RequiresIndexDocuments = __parseBoolean(output["RequiresIndexDocuments"]);
@@ -2634,18 +2634,18 @@ const deserializeAws_queryDomainStatus = (output, context) => {
         contents.SearchInstanceCount = __strictParseInt32(output["SearchInstanceCount"]);
     }
     if (output["Limits"] !== undefined) {
-        contents.Limits = deserializeAws_queryLimits(output["Limits"], context);
+        contents.Limits = de_Limits(output["Limits"], context);
     }
     return contents;
 };
-const deserializeAws_queryDomainStatusList = (output, context) => {
+const de_DomainStatusList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryDomainStatus(entry, context);
+        return de_DomainStatus(entry, context);
     });
 };
-const deserializeAws_queryDoubleArrayOptions = (output, context) => {
+const de_DoubleArrayOptions = (output, context) => {
     const contents = {};
     if (output["DefaultValue"] !== undefined) {
         contents.DefaultValue = __strictParseFloat(output["DefaultValue"]);
@@ -2664,7 +2664,7 @@ const deserializeAws_queryDoubleArrayOptions = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryDoubleOptions = (output, context) => {
+const de_DoubleOptions = (output, context) => {
     const contents = {};
     if (output["DefaultValue"] !== undefined) {
         contents.DefaultValue = __strictParseFloat(output["DefaultValue"]);
@@ -2686,7 +2686,7 @@ const deserializeAws_queryDoubleOptions = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryExpression = (output, context) => {
+const de_Expression = (output, context) => {
     const contents = {};
     if (output["ExpressionName"] !== undefined) {
         contents.ExpressionName = __expectString(output["ExpressionName"]);
@@ -2696,41 +2696,41 @@ const deserializeAws_queryExpression = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryExpressionStatus = (output, context) => {
+const de_ExpressionStatus = (output, context) => {
     const contents = {};
     if (output["Options"] !== undefined) {
-        contents.Options = deserializeAws_queryExpression(output["Options"], context);
+        contents.Options = de_Expression(output["Options"], context);
     }
     if (output["Status"] !== undefined) {
-        contents.Status = deserializeAws_queryOptionStatus(output["Status"], context);
+        contents.Status = de_OptionStatus(output["Status"], context);
     }
     return contents;
 };
-const deserializeAws_queryExpressionStatusList = (output, context) => {
+const de_ExpressionStatusList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryExpressionStatus(entry, context);
+        return de_ExpressionStatus(entry, context);
     });
 };
-const deserializeAws_queryFieldNameList = (output, context) => {
+const de_FieldNameList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         return __expectString(entry);
     });
 };
-const deserializeAws_queryIndexDocumentsResponse = (output, context) => {
+const de_IndexDocumentsResponse = (output, context) => {
     const contents = {};
     if (output.FieldNames === "") {
         contents.FieldNames = [];
     }
     else if (output["FieldNames"] !== undefined && output["FieldNames"]["member"] !== undefined) {
-        contents.FieldNames = deserializeAws_queryFieldNameList(__getArrayIfSingleItem(output["FieldNames"]["member"]), context);
+        contents.FieldNames = de_FieldNameList(__getArrayIfSingleItem(output["FieldNames"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryIndexField = (output, context) => {
+const de_IndexField = (output, context) => {
     const contents = {};
     if (output["IndexFieldName"] !== undefined) {
         contents.IndexFieldName = __expectString(output["IndexFieldName"]);
@@ -2739,58 +2739,58 @@ const deserializeAws_queryIndexField = (output, context) => {
         contents.IndexFieldType = __expectString(output["IndexFieldType"]);
     }
     if (output["IntOptions"] !== undefined) {
-        contents.IntOptions = deserializeAws_queryIntOptions(output["IntOptions"], context);
+        contents.IntOptions = de_IntOptions(output["IntOptions"], context);
     }
     if (output["DoubleOptions"] !== undefined) {
-        contents.DoubleOptions = deserializeAws_queryDoubleOptions(output["DoubleOptions"], context);
+        contents.DoubleOptions = de_DoubleOptions(output["DoubleOptions"], context);
     }
     if (output["LiteralOptions"] !== undefined) {
-        contents.LiteralOptions = deserializeAws_queryLiteralOptions(output["LiteralOptions"], context);
+        contents.LiteralOptions = de_LiteralOptions(output["LiteralOptions"], context);
     }
     if (output["TextOptions"] !== undefined) {
-        contents.TextOptions = deserializeAws_queryTextOptions(output["TextOptions"], context);
+        contents.TextOptions = de_TextOptions(output["TextOptions"], context);
     }
     if (output["DateOptions"] !== undefined) {
-        contents.DateOptions = deserializeAws_queryDateOptions(output["DateOptions"], context);
+        contents.DateOptions = de_DateOptions(output["DateOptions"], context);
     }
     if (output["LatLonOptions"] !== undefined) {
-        contents.LatLonOptions = deserializeAws_queryLatLonOptions(output["LatLonOptions"], context);
+        contents.LatLonOptions = de_LatLonOptions(output["LatLonOptions"], context);
     }
     if (output["IntArrayOptions"] !== undefined) {
-        contents.IntArrayOptions = deserializeAws_queryIntArrayOptions(output["IntArrayOptions"], context);
+        contents.IntArrayOptions = de_IntArrayOptions(output["IntArrayOptions"], context);
     }
     if (output["DoubleArrayOptions"] !== undefined) {
-        contents.DoubleArrayOptions = deserializeAws_queryDoubleArrayOptions(output["DoubleArrayOptions"], context);
+        contents.DoubleArrayOptions = de_DoubleArrayOptions(output["DoubleArrayOptions"], context);
     }
     if (output["LiteralArrayOptions"] !== undefined) {
-        contents.LiteralArrayOptions = deserializeAws_queryLiteralArrayOptions(output["LiteralArrayOptions"], context);
+        contents.LiteralArrayOptions = de_LiteralArrayOptions(output["LiteralArrayOptions"], context);
     }
     if (output["TextArrayOptions"] !== undefined) {
-        contents.TextArrayOptions = deserializeAws_queryTextArrayOptions(output["TextArrayOptions"], context);
+        contents.TextArrayOptions = de_TextArrayOptions(output["TextArrayOptions"], context);
     }
     if (output["DateArrayOptions"] !== undefined) {
-        contents.DateArrayOptions = deserializeAws_queryDateArrayOptions(output["DateArrayOptions"], context);
+        contents.DateArrayOptions = de_DateArrayOptions(output["DateArrayOptions"], context);
     }
     return contents;
 };
-const deserializeAws_queryIndexFieldStatus = (output, context) => {
+const de_IndexFieldStatus = (output, context) => {
     const contents = {};
     if (output["Options"] !== undefined) {
-        contents.Options = deserializeAws_queryIndexField(output["Options"], context);
+        contents.Options = de_IndexField(output["Options"], context);
     }
     if (output["Status"] !== undefined) {
-        contents.Status = deserializeAws_queryOptionStatus(output["Status"], context);
+        contents.Status = de_OptionStatus(output["Status"], context);
     }
     return contents;
 };
-const deserializeAws_queryIndexFieldStatusList = (output, context) => {
+const de_IndexFieldStatusList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryIndexFieldStatus(entry, context);
+        return de_IndexFieldStatus(entry, context);
     });
 };
-const deserializeAws_queryIntArrayOptions = (output, context) => {
+const de_IntArrayOptions = (output, context) => {
     const contents = {};
     if (output["DefaultValue"] !== undefined) {
         contents.DefaultValue = __strictParseLong(output["DefaultValue"]);
@@ -2809,7 +2809,7 @@ const deserializeAws_queryIntArrayOptions = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryInternalException = (output, context) => {
+const de_InternalException = (output, context) => {
     const contents = {};
     if (output["Code"] !== undefined) {
         contents.Code = __expectString(output["Code"]);
@@ -2819,7 +2819,7 @@ const deserializeAws_queryInternalException = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryIntOptions = (output, context) => {
+const de_IntOptions = (output, context) => {
     const contents = {};
     if (output["DefaultValue"] !== undefined) {
         contents.DefaultValue = __strictParseLong(output["DefaultValue"]);
@@ -2841,7 +2841,7 @@ const deserializeAws_queryIntOptions = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryInvalidTypeException = (output, context) => {
+const de_InvalidTypeException = (output, context) => {
     const contents = {};
     if (output["Code"] !== undefined) {
         contents.Code = __expectString(output["Code"]);
@@ -2851,7 +2851,7 @@ const deserializeAws_queryInvalidTypeException = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryLatLonOptions = (output, context) => {
+const de_LatLonOptions = (output, context) => {
     const contents = {};
     if (output["DefaultValue"] !== undefined) {
         contents.DefaultValue = __expectString(output["DefaultValue"]);
@@ -2873,7 +2873,7 @@ const deserializeAws_queryLatLonOptions = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryLimitExceededException = (output, context) => {
+const de_LimitExceededException = (output, context) => {
     const contents = {};
     if (output["Code"] !== undefined) {
         contents.Code = __expectString(output["Code"]);
@@ -2883,7 +2883,7 @@ const deserializeAws_queryLimitExceededException = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryLimits = (output, context) => {
+const de_Limits = (output, context) => {
     const contents = {};
     if (output["MaximumReplicationCount"] !== undefined) {
         contents.MaximumReplicationCount = __strictParseInt32(output["MaximumReplicationCount"]);
@@ -2893,17 +2893,17 @@ const deserializeAws_queryLimits = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryListDomainNamesResponse = (output, context) => {
+const de_ListDomainNamesResponse = (output, context) => {
     const contents = {};
     if (output.DomainNames === "") {
         contents.DomainNames = {};
     }
     else if (output["DomainNames"] !== undefined && output["DomainNames"]["entry"] !== undefined) {
-        contents.DomainNames = deserializeAws_queryDomainNameMap(__getArrayIfSingleItem(output["DomainNames"]["entry"]), context);
+        contents.DomainNames = de_DomainNameMap(__getArrayIfSingleItem(output["DomainNames"]["entry"]), context);
     }
     return contents;
 };
-const deserializeAws_queryLiteralArrayOptions = (output, context) => {
+const de_LiteralArrayOptions = (output, context) => {
     const contents = {};
     if (output["DefaultValue"] !== undefined) {
         contents.DefaultValue = __expectString(output["DefaultValue"]);
@@ -2922,7 +2922,7 @@ const deserializeAws_queryLiteralArrayOptions = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryLiteralOptions = (output, context) => {
+const de_LiteralOptions = (output, context) => {
     const contents = {};
     if (output["DefaultValue"] !== undefined) {
         contents.DefaultValue = __expectString(output["DefaultValue"]);
@@ -2944,7 +2944,7 @@ const deserializeAws_queryLiteralOptions = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryOptionStatus = (output, context) => {
+const de_OptionStatus = (output, context) => {
     const contents = {};
     if (output["CreationDate"] !== undefined) {
         contents.CreationDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(output["CreationDate"]));
@@ -2963,7 +2963,7 @@ const deserializeAws_queryOptionStatus = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryResourceAlreadyExistsException = (output, context) => {
+const de_ResourceAlreadyExistsException = (output, context) => {
     const contents = {};
     if (output["Code"] !== undefined) {
         contents.Code = __expectString(output["Code"]);
@@ -2973,7 +2973,7 @@ const deserializeAws_queryResourceAlreadyExistsException = (output, context) =>
     }
     return contents;
 };
-const deserializeAws_queryResourceNotFoundException = (output, context) => {
+const de_ResourceNotFoundException = (output, context) => {
     const contents = {};
     if (output["Code"] !== undefined) {
         contents.Code = __expectString(output["Code"]);
@@ -2983,7 +2983,7 @@ const deserializeAws_queryResourceNotFoundException = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryScalingParameters = (output, context) => {
+const de_ScalingParameters = (output, context) => {
     const contents = {};
     if (output["DesiredInstanceType"] !== undefined) {
         contents.DesiredInstanceType = __expectString(output["DesiredInstanceType"]);
@@ -2996,51 +2996,51 @@ const deserializeAws_queryScalingParameters = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryScalingParametersStatus = (output, context) => {
+const de_ScalingParametersStatus = (output, context) => {
     const contents = {};
     if (output["Options"] !== undefined) {
-        contents.Options = deserializeAws_queryScalingParameters(output["Options"], context);
+        contents.Options = de_ScalingParameters(output["Options"], context);
     }
     if (output["Status"] !== undefined) {
-        contents.Status = deserializeAws_queryOptionStatus(output["Status"], context);
+        contents.Status = de_OptionStatus(output["Status"], context);
     }
     return contents;
 };
-const deserializeAws_queryServiceEndpoint = (output, context) => {
+const de_ServiceEndpoint = (output, context) => {
     const contents = {};
     if (output["Endpoint"] !== undefined) {
         contents.Endpoint = __expectString(output["Endpoint"]);
     }
     return contents;
 };
-const deserializeAws_querySuggester = (output, context) => {
+const de_Suggester = (output, context) => {
     const contents = {};
     if (output["SuggesterName"] !== undefined) {
         contents.SuggesterName = __expectString(output["SuggesterName"]);
     }
     if (output["DocumentSuggesterOptions"] !== undefined) {
-        contents.DocumentSuggesterOptions = deserializeAws_queryDocumentSuggesterOptions(output["DocumentSuggesterOptions"], context);
+        contents.DocumentSuggesterOptions = de_DocumentSuggesterOptions(output["DocumentSuggesterOptions"], context);
     }
     return contents;
 };
-const deserializeAws_querySuggesterStatus = (output, context) => {
+const de_SuggesterStatus = (output, context) => {
     const contents = {};
     if (output["Options"] !== undefined) {
-        contents.Options = deserializeAws_querySuggester(output["Options"], context);
+        contents.Options = de_Suggester(output["Options"], context);
     }
     if (output["Status"] !== undefined) {
-        contents.Status = deserializeAws_queryOptionStatus(output["Status"], context);
+        contents.Status = de_OptionStatus(output["Status"], context);
     }
     return contents;
 };
-const deserializeAws_querySuggesterStatusList = (output, context) => {
+const de_SuggesterStatusList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_querySuggesterStatus(entry, context);
+        return de_SuggesterStatus(entry, context);
     });
 };
-const deserializeAws_queryTextArrayOptions = (output, context) => {
+const de_TextArrayOptions = (output, context) => {
     const contents = {};
     if (output["DefaultValue"] !== undefined) {
         contents.DefaultValue = __expectString(output["DefaultValue"]);
@@ -3059,7 +3059,7 @@ const deserializeAws_queryTextArrayOptions = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryTextOptions = (output, context) => {
+const de_TextOptions = (output, context) => {
     const contents = {};
     if (output["DefaultValue"] !== undefined) {
         contents.DefaultValue = __expectString(output["DefaultValue"]);
@@ -3081,35 +3081,35 @@ const deserializeAws_queryTextOptions = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryUpdateAvailabilityOptionsResponse = (output, context) => {
+const de_UpdateAvailabilityOptionsResponse = (output, context) => {
     const contents = {};
     if (output["AvailabilityOptions"] !== undefined) {
-        contents.AvailabilityOptions = deserializeAws_queryAvailabilityOptionsStatus(output["AvailabilityOptions"], context);
+        contents.AvailabilityOptions = de_AvailabilityOptionsStatus(output["AvailabilityOptions"], context);
     }
     return contents;
 };
-const deserializeAws_queryUpdateDomainEndpointOptionsResponse = (output, context) => {
+const de_UpdateDomainEndpointOptionsResponse = (output, context) => {
     const contents = {};
     if (output["DomainEndpointOptions"] !== undefined) {
-        contents.DomainEndpointOptions = deserializeAws_queryDomainEndpointOptionsStatus(output["DomainEndpointOptions"], context);
+        contents.DomainEndpointOptions = de_DomainEndpointOptionsStatus(output["DomainEndpointOptions"], context);
     }
     return contents;
 };
-const deserializeAws_queryUpdateScalingParametersResponse = (output, context) => {
+const de_UpdateScalingParametersResponse = (output, context) => {
     const contents = {};
     if (output["ScalingParameters"] !== undefined) {
-        contents.ScalingParameters = deserializeAws_queryScalingParametersStatus(output["ScalingParameters"], context);
+        contents.ScalingParameters = de_ScalingParametersStatus(output["ScalingParameters"], context);
     }
     return contents;
 };
-const deserializeAws_queryUpdateServiceAccessPoliciesResponse = (output, context) => {
+const de_UpdateServiceAccessPoliciesResponse = (output, context) => {
     const contents = {};
     if (output["AccessPolicies"] !== undefined) {
-        contents.AccessPolicies = deserializeAws_queryAccessPoliciesStatus(output["AccessPolicies"], context);
+        contents.AccessPolicies = de_AccessPoliciesStatus(output["AccessPolicies"], context);
     }
     return contents;
 };
-const deserializeAws_queryValidationException = (output, context) => {
+const de_ValidationException = (output, context) => {
     const contents = {};
     if (output["Code"] !== undefined) {
         contents.Code = __expectString(output["Code"]);