@aws-sdk/client-elastic-load-balancing 3.306.0 → 3.309.0

package/dist-es/protocols/Aws_query.js

@@ -3,368 +3,368 @@ import { decorateServiceException as __decorateServiceException, expectNonNull a
 import { XMLParser } from "fast-xml-parser";
 import { ElasticLoadBalancingServiceException as __BaseException } from "../models/ElasticLoadBalancingServiceException";
 import { AccessPointNotFoundException, CertificateNotFoundException, DependencyThrottleException, DuplicateAccessPointNameException, DuplicateListenerException, DuplicatePolicyNameException, DuplicateTagKeysException, InvalidConfigurationRequestException, InvalidEndPointException, InvalidSchemeException, InvalidSecurityGroupException, InvalidSubnetException, ListenerNotFoundException, LoadBalancerAttributeNotFoundException, OperationNotPermittedException, PolicyNotFoundException, PolicyTypeNotFoundException, SubnetNotFoundException, TooManyAccessPointsException, TooManyPoliciesException, TooManyTagsException, UnsupportedProtocolException, } from "../models/models_0";
-export const serializeAws_queryAddTagsCommand = async (input, context) => {
+export const se_AddTagsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryAddTagsInput(input, context),
+        ...se_AddTagsInput(input, context),
         Action: "AddTags",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryApplySecurityGroupsToLoadBalancerCommand = async (input, context) => {
+export const se_ApplySecurityGroupsToLoadBalancerCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryApplySecurityGroupsToLoadBalancerInput(input, context),
+        ...se_ApplySecurityGroupsToLoadBalancerInput(input, context),
         Action: "ApplySecurityGroupsToLoadBalancer",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryAttachLoadBalancerToSubnetsCommand = async (input, context) => {
+export const se_AttachLoadBalancerToSubnetsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryAttachLoadBalancerToSubnetsInput(input, context),
+        ...se_AttachLoadBalancerToSubnetsInput(input, context),
         Action: "AttachLoadBalancerToSubnets",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryConfigureHealthCheckCommand = async (input, context) => {
+export const se_ConfigureHealthCheckCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryConfigureHealthCheckInput(input, context),
+        ...se_ConfigureHealthCheckInput(input, context),
         Action: "ConfigureHealthCheck",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryCreateAppCookieStickinessPolicyCommand = async (input, context) => {
+export const se_CreateAppCookieStickinessPolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryCreateAppCookieStickinessPolicyInput(input, context),
+        ...se_CreateAppCookieStickinessPolicyInput(input, context),
         Action: "CreateAppCookieStickinessPolicy",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryCreateLBCookieStickinessPolicyCommand = async (input, context) => {
+export const se_CreateLBCookieStickinessPolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryCreateLBCookieStickinessPolicyInput(input, context),
+        ...se_CreateLBCookieStickinessPolicyInput(input, context),
         Action: "CreateLBCookieStickinessPolicy",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryCreateLoadBalancerCommand = async (input, context) => {
+export const se_CreateLoadBalancerCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryCreateAccessPointInput(input, context),
+        ...se_CreateAccessPointInput(input, context),
         Action: "CreateLoadBalancer",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryCreateLoadBalancerListenersCommand = async (input, context) => {
+export const se_CreateLoadBalancerListenersCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryCreateLoadBalancerListenerInput(input, context),
+        ...se_CreateLoadBalancerListenerInput(input, context),
         Action: "CreateLoadBalancerListeners",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryCreateLoadBalancerPolicyCommand = async (input, context) => {
+export const se_CreateLoadBalancerPolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryCreateLoadBalancerPolicyInput(input, context),
+        ...se_CreateLoadBalancerPolicyInput(input, context),
         Action: "CreateLoadBalancerPolicy",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDeleteLoadBalancerCommand = async (input, context) => {
+export const se_DeleteLoadBalancerCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteAccessPointInput(input, context),
+        ...se_DeleteAccessPointInput(input, context),
         Action: "DeleteLoadBalancer",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDeleteLoadBalancerListenersCommand = async (input, context) => {
+export const se_DeleteLoadBalancerListenersCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteLoadBalancerListenerInput(input, context),
+        ...se_DeleteLoadBalancerListenerInput(input, context),
         Action: "DeleteLoadBalancerListeners",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDeleteLoadBalancerPolicyCommand = async (input, context) => {
+export const se_DeleteLoadBalancerPolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeleteLoadBalancerPolicyInput(input, context),
+        ...se_DeleteLoadBalancerPolicyInput(input, context),
         Action: "DeleteLoadBalancerPolicy",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDeregisterInstancesFromLoadBalancerCommand = async (input, context) => {
+export const se_DeregisterInstancesFromLoadBalancerCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDeregisterEndPointsInput(input, context),
+        ...se_DeregisterEndPointsInput(input, context),
         Action: "DeregisterInstancesFromLoadBalancer",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeAccountLimitsCommand = async (input, context) => {
+export const se_DescribeAccountLimitsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeAccountLimitsInput(input, context),
+        ...se_DescribeAccountLimitsInput(input, context),
         Action: "DescribeAccountLimits",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeInstanceHealthCommand = async (input, context) => {
+export const se_DescribeInstanceHealthCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeEndPointStateInput(input, context),
+        ...se_DescribeEndPointStateInput(input, context),
         Action: "DescribeInstanceHealth",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeLoadBalancerAttributesCommand = async (input, context) => {
+export const se_DescribeLoadBalancerAttributesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeLoadBalancerAttributesInput(input, context),
+        ...se_DescribeLoadBalancerAttributesInput(input, context),
         Action: "DescribeLoadBalancerAttributes",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeLoadBalancerPoliciesCommand = async (input, context) => {
+export const se_DescribeLoadBalancerPoliciesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeLoadBalancerPoliciesInput(input, context),
+        ...se_DescribeLoadBalancerPoliciesInput(input, context),
         Action: "DescribeLoadBalancerPolicies",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeLoadBalancerPolicyTypesCommand = async (input, context) => {
+export const se_DescribeLoadBalancerPolicyTypesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeLoadBalancerPolicyTypesInput(input, context),
+        ...se_DescribeLoadBalancerPolicyTypesInput(input, context),
         Action: "DescribeLoadBalancerPolicyTypes",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeLoadBalancersCommand = async (input, context) => {
+export const se_DescribeLoadBalancersCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeAccessPointsInput(input, context),
+        ...se_DescribeAccessPointsInput(input, context),
         Action: "DescribeLoadBalancers",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDescribeTagsCommand = async (input, context) => {
+export const se_DescribeTagsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDescribeTagsInput(input, context),
+        ...se_DescribeTagsInput(input, context),
         Action: "DescribeTags",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDetachLoadBalancerFromSubnetsCommand = async (input, context) => {
+export const se_DetachLoadBalancerFromSubnetsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryDetachLoadBalancerFromSubnetsInput(input, context),
+        ...se_DetachLoadBalancerFromSubnetsInput(input, context),
         Action: "DetachLoadBalancerFromSubnets",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryDisableAvailabilityZonesForLoadBalancerCommand = async (input, context) => {
+export const se_DisableAvailabilityZonesForLoadBalancerCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryRemoveAvailabilityZonesInput(input, context),
+        ...se_RemoveAvailabilityZonesInput(input, context),
         Action: "DisableAvailabilityZonesForLoadBalancer",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryEnableAvailabilityZonesForLoadBalancerCommand = async (input, context) => {
+export const se_EnableAvailabilityZonesForLoadBalancerCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryAddAvailabilityZonesInput(input, context),
+        ...se_AddAvailabilityZonesInput(input, context),
         Action: "EnableAvailabilityZonesForLoadBalancer",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryModifyLoadBalancerAttributesCommand = async (input, context) => {
+export const se_ModifyLoadBalancerAttributesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryModifyLoadBalancerAttributesInput(input, context),
+        ...se_ModifyLoadBalancerAttributesInput(input, context),
         Action: "ModifyLoadBalancerAttributes",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryRegisterInstancesWithLoadBalancerCommand = async (input, context) => {
+export const se_RegisterInstancesWithLoadBalancerCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryRegisterEndPointsInput(input, context),
+        ...se_RegisterEndPointsInput(input, context),
         Action: "RegisterInstancesWithLoadBalancer",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_queryRemoveTagsCommand = async (input, context) => {
+export const se_RemoveTagsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_queryRemoveTagsInput(input, context),
+        ...se_RemoveTagsInput(input, context),
         Action: "RemoveTags",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_querySetLoadBalancerListenerSSLCertificateCommand = async (input, context) => {
+export const se_SetLoadBalancerListenerSSLCertificateCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_querySetLoadBalancerListenerSSLCertificateInput(input, context),
+        ...se_SetLoadBalancerListenerSSLCertificateInput(input, context),
         Action: "SetLoadBalancerListenerSSLCertificate",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_querySetLoadBalancerPoliciesForBackendServerCommand = async (input, context) => {
+export const se_SetLoadBalancerPoliciesForBackendServerCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_querySetLoadBalancerPoliciesForBackendServerInput(input, context),
+        ...se_SetLoadBalancerPoliciesForBackendServerInput(input, context),
         Action: "SetLoadBalancerPoliciesForBackendServer",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_querySetLoadBalancerPoliciesOfListenerCommand = async (input, context) => {
+export const se_SetLoadBalancerPoliciesOfListenerCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
     };
     let body;
     body = buildFormUrlencodedString({
-        ...serializeAws_querySetLoadBalancerPoliciesOfListenerInput(input, context),
+        ...se_SetLoadBalancerPoliciesOfListenerInput(input, context),
         Action: "SetLoadBalancerPoliciesOfListener",
         Version: "2012-06-01",
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const deserializeAws_queryAddTagsCommand = async (output, context) => {
+export const de_AddTagsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryAddTagsCommandError(output, context);
+        return de_AddTagsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryAddTagsOutput(data.AddTagsResult, context);
+    contents = de_AddTagsOutput(data.AddTagsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryAddTagsCommandError = async (output, context) => {
+const de_AddTagsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -373,13 +373,13 @@ const deserializeAws_queryAddTagsCommandError = async (output, context) => {
     switch (errorCode) {
         case "DuplicateTagKeys":
         case "com.amazonaws.elasticloadbalancing#DuplicateTagKeysException":
-            throw await deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context);
+            throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         case "TooManyTags":
         case "com.amazonaws.elasticloadbalancing#TooManyTagsException":
-            throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -390,20 +390,20 @@ const deserializeAws_queryAddTagsCommandError = async (output, context) => {
             });
     }
 };
-export const deserializeAws_queryApplySecurityGroupsToLoadBalancerCommand = async (output, context) => {
+export const de_ApplySecurityGroupsToLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryApplySecurityGroupsToLoadBalancerCommandError(output, context);
+        return de_ApplySecurityGroupsToLoadBalancerCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryApplySecurityGroupsToLoadBalancerOutput(data.ApplySecurityGroupsToLoadBalancerResult, context);
+    contents = de_ApplySecurityGroupsToLoadBalancerOutput(data.ApplySecurityGroupsToLoadBalancerResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryApplySecurityGroupsToLoadBalancerCommandError = async (output, context) => {
+const de_ApplySecurityGroupsToLoadBalancerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -412,13 +412,13 @@ const deserializeAws_queryApplySecurityGroupsToLoadBalancerCommandError = async
     switch (errorCode) {
         case "InvalidConfigurationRequest":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
         case "InvalidSecurityGroup":
         case "com.amazonaws.elasticloadbalancing#InvalidSecurityGroupException":
-            throw await deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context);
+            throw await de_InvalidSecurityGroupExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -429,20 +429,20 @@ const deserializeAws_queryApplySecurityGroupsToLoadBalancerCommandError = async
             });
     }
 };
-export const deserializeAws_queryAttachLoadBalancerToSubnetsCommand = async (output, context) => {
+export const de_AttachLoadBalancerToSubnetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryAttachLoadBalancerToSubnetsCommandError(output, context);
+        return de_AttachLoadBalancerToSubnetsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryAttachLoadBalancerToSubnetsOutput(data.AttachLoadBalancerToSubnetsResult, context);
+    contents = de_AttachLoadBalancerToSubnetsOutput(data.AttachLoadBalancerToSubnetsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryAttachLoadBalancerToSubnetsCommandError = async (output, context) => {
+const de_AttachLoadBalancerToSubnetsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -451,16 +451,16 @@ const deserializeAws_queryAttachLoadBalancerToSubnetsCommandError = async (outpu
     switch (errorCode) {
         case "InvalidConfigurationRequest":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
         case "InvalidSubnet":
         case "com.amazonaws.elasticloadbalancing#InvalidSubnetException":
-            throw await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context);
+            throw await de_InvalidSubnetExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         case "SubnetNotFound":
         case "com.amazonaws.elasticloadbalancing#SubnetNotFoundException":
-            throw await deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_SubnetNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -471,20 +471,20 @@ const deserializeAws_queryAttachLoadBalancerToSubnetsCommandError = async (outpu
             });
     }
 };
-export const deserializeAws_queryConfigureHealthCheckCommand = async (output, context) => {
+export const de_ConfigureHealthCheckCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryConfigureHealthCheckCommandError(output, context);
+        return de_ConfigureHealthCheckCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryConfigureHealthCheckOutput(data.ConfigureHealthCheckResult, context);
+    contents = de_ConfigureHealthCheckOutput(data.ConfigureHealthCheckResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryConfigureHealthCheckCommandError = async (output, context) => {
+const de_ConfigureHealthCheckCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -493,7 +493,7 @@ const deserializeAws_queryConfigureHealthCheckCommandError = async (output, cont
     switch (errorCode) {
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -504,20 +504,20 @@ const deserializeAws_queryConfigureHealthCheckCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_queryCreateAppCookieStickinessPolicyCommand = async (output, context) => {
+export const de_CreateAppCookieStickinessPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryCreateAppCookieStickinessPolicyCommandError(output, context);
+        return de_CreateAppCookieStickinessPolicyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryCreateAppCookieStickinessPolicyOutput(data.CreateAppCookieStickinessPolicyResult, context);
+    contents = de_CreateAppCookieStickinessPolicyOutput(data.CreateAppCookieStickinessPolicyResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryCreateAppCookieStickinessPolicyCommandError = async (output, context) => {
+const de_CreateAppCookieStickinessPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -526,16 +526,16 @@ const deserializeAws_queryCreateAppCookieStickinessPolicyCommandError = async (o
     switch (errorCode) {
         case "DuplicatePolicyName":
         case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException":
-            throw await deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context);
+            throw await de_DuplicatePolicyNameExceptionRes(parsedOutput, context);
         case "InvalidConfigurationRequest":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         case "TooManyPolicies":
         case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException":
-            throw await deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context);
+            throw await de_TooManyPoliciesExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -546,20 +546,20 @@ const deserializeAws_queryCreateAppCookieStickinessPolicyCommandError = async (o
             });
     }
 };
-export const deserializeAws_queryCreateLBCookieStickinessPolicyCommand = async (output, context) => {
+export const de_CreateLBCookieStickinessPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryCreateLBCookieStickinessPolicyCommandError(output, context);
+        return de_CreateLBCookieStickinessPolicyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryCreateLBCookieStickinessPolicyOutput(data.CreateLBCookieStickinessPolicyResult, context);
+    contents = de_CreateLBCookieStickinessPolicyOutput(data.CreateLBCookieStickinessPolicyResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryCreateLBCookieStickinessPolicyCommandError = async (output, context) => {
+const de_CreateLBCookieStickinessPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -568,16 +568,16 @@ const deserializeAws_queryCreateLBCookieStickinessPolicyCommandError = async (ou
     switch (errorCode) {
         case "DuplicatePolicyName":
         case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException":
-            throw await deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context);
+            throw await de_DuplicatePolicyNameExceptionRes(parsedOutput, context);
         case "InvalidConfigurationRequest":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         case "TooManyPolicies":
         case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException":
-            throw await deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context);
+            throw await de_TooManyPoliciesExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -588,20 +588,20 @@ const deserializeAws_queryCreateLBCookieStickinessPolicyCommandError = async (ou
             });
     }
 };
-export const deserializeAws_queryCreateLoadBalancerCommand = async (output, context) => {
+export const de_CreateLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryCreateLoadBalancerCommandError(output, context);
+        return de_CreateLoadBalancerCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryCreateAccessPointOutput(data.CreateLoadBalancerResult, context);
+    contents = de_CreateAccessPointOutput(data.CreateLoadBalancerResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryCreateLoadBalancerCommandError = async (output, context) => {
+const de_CreateLoadBalancerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -610,40 +610,40 @@ const deserializeAws_queryCreateLoadBalancerCommandError = async (output, contex
     switch (errorCode) {
         case "CertificateNotFound":
         case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException":
-            throw await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_CertificateNotFoundExceptionRes(parsedOutput, context);
         case "DuplicateLoadBalancerName":
         case "com.amazonaws.elasticloadbalancing#DuplicateAccessPointNameException":
-            throw await deserializeAws_queryDuplicateAccessPointNameExceptionResponse(parsedOutput, context);
+            throw await de_DuplicateAccessPointNameExceptionRes(parsedOutput, context);
         case "DuplicateTagKeys":
         case "com.amazonaws.elasticloadbalancing#DuplicateTagKeysException":
-            throw await deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context);
+            throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
         case "InvalidConfigurationRequest":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
         case "InvalidScheme":
         case "com.amazonaws.elasticloadbalancing#InvalidSchemeException":
-            throw await deserializeAws_queryInvalidSchemeExceptionResponse(parsedOutput, context);
+            throw await de_InvalidSchemeExceptionRes(parsedOutput, context);
         case "InvalidSecurityGroup":
         case "com.amazonaws.elasticloadbalancing#InvalidSecurityGroupException":
-            throw await deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context);
+            throw await de_InvalidSecurityGroupExceptionRes(parsedOutput, context);
         case "InvalidSubnet":
         case "com.amazonaws.elasticloadbalancing#InvalidSubnetException":
-            throw await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context);
+            throw await de_InvalidSubnetExceptionRes(parsedOutput, context);
         case "OperationNotPermitted":
         case "com.amazonaws.elasticloadbalancing#OperationNotPermittedException":
-            throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
+            throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
         case "SubnetNotFound":
         case "com.amazonaws.elasticloadbalancing#SubnetNotFoundException":
-            throw await deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_SubnetNotFoundExceptionRes(parsedOutput, context);
         case "TooManyLoadBalancers":
         case "com.amazonaws.elasticloadbalancing#TooManyAccessPointsException":
-            throw await deserializeAws_queryTooManyAccessPointsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyAccessPointsExceptionRes(parsedOutput, context);
         case "TooManyTags":
         case "com.amazonaws.elasticloadbalancing#TooManyTagsException":
-            throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
         case "UnsupportedProtocol":
         case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException":
-            throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedProtocolExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -654,20 +654,20 @@ const deserializeAws_queryCreateLoadBalancerCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_queryCreateLoadBalancerListenersCommand = async (output, context) => {
+export const de_CreateLoadBalancerListenersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryCreateLoadBalancerListenersCommandError(output, context);
+        return de_CreateLoadBalancerListenersCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryCreateLoadBalancerListenerOutput(data.CreateLoadBalancerListenersResult, context);
+    contents = de_CreateLoadBalancerListenerOutput(data.CreateLoadBalancerListenersResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryCreateLoadBalancerListenersCommandError = async (output, context) => {
+const de_CreateLoadBalancerListenersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -676,19 +676,19 @@ const deserializeAws_queryCreateLoadBalancerListenersCommandError = async (outpu
     switch (errorCode) {
         case "CertificateNotFound":
         case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException":
-            throw await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_CertificateNotFoundExceptionRes(parsedOutput, context);
         case "DuplicateListener":
         case "com.amazonaws.elasticloadbalancing#DuplicateListenerException":
-            throw await deserializeAws_queryDuplicateListenerExceptionResponse(parsedOutput, context);
+            throw await de_DuplicateListenerExceptionRes(parsedOutput, context);
         case "InvalidConfigurationRequest":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         case "UnsupportedProtocol":
         case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException":
-            throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedProtocolExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -699,20 +699,20 @@ const deserializeAws_queryCreateLoadBalancerListenersCommandError = async (outpu
             });
     }
 };
-export const deserializeAws_queryCreateLoadBalancerPolicyCommand = async (output, context) => {
+export const de_CreateLoadBalancerPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryCreateLoadBalancerPolicyCommandError(output, context);
+        return de_CreateLoadBalancerPolicyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryCreateLoadBalancerPolicyOutput(data.CreateLoadBalancerPolicyResult, context);
+    contents = de_CreateLoadBalancerPolicyOutput(data.CreateLoadBalancerPolicyResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryCreateLoadBalancerPolicyCommandError = async (output, context) => {
+const de_CreateLoadBalancerPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -721,19 +721,19 @@ const deserializeAws_queryCreateLoadBalancerPolicyCommandError = async (output,
     switch (errorCode) {
         case "DuplicatePolicyName":
         case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException":
-            throw await deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context);
+            throw await de_DuplicatePolicyNameExceptionRes(parsedOutput, context);
         case "InvalidConfigurationRequest":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         case "PolicyTypeNotFound":
         case "com.amazonaws.elasticloadbalancing#PolicyTypeNotFoundException":
-            throw await deserializeAws_queryPolicyTypeNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PolicyTypeNotFoundExceptionRes(parsedOutput, context);
         case "TooManyPolicies":
         case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException":
-            throw await deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context);
+            throw await de_TooManyPoliciesExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -744,20 +744,20 @@ const deserializeAws_queryCreateLoadBalancerPolicyCommandError = async (output,
             });
     }
 };
-export const deserializeAws_queryDeleteLoadBalancerCommand = async (output, context) => {
+export const de_DeleteLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteLoadBalancerCommandError(output, context);
+        return de_DeleteLoadBalancerCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDeleteAccessPointOutput(data.DeleteLoadBalancerResult, context);
+    contents = de_DeleteAccessPointOutput(data.DeleteLoadBalancerResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDeleteLoadBalancerCommandError = async (output, context) => {
+const de_DeleteLoadBalancerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -771,20 +771,20 @@ const deserializeAws_queryDeleteLoadBalancerCommandError = async (output, contex
         errorCode,
     });
 };
-export const deserializeAws_queryDeleteLoadBalancerListenersCommand = async (output, context) => {
+export const de_DeleteLoadBalancerListenersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteLoadBalancerListenersCommandError(output, context);
+        return de_DeleteLoadBalancerListenersCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDeleteLoadBalancerListenerOutput(data.DeleteLoadBalancerListenersResult, context);
+    contents = de_DeleteLoadBalancerListenerOutput(data.DeleteLoadBalancerListenersResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDeleteLoadBalancerListenersCommandError = async (output, context) => {
+const de_DeleteLoadBalancerListenersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -793,7 +793,7 @@ const deserializeAws_queryDeleteLoadBalancerListenersCommandError = async (outpu
     switch (errorCode) {
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -804,20 +804,20 @@ const deserializeAws_queryDeleteLoadBalancerListenersCommandError = async (outpu
             });
     }
 };
-export const deserializeAws_queryDeleteLoadBalancerPolicyCommand = async (output, context) => {
+export const de_DeleteLoadBalancerPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeleteLoadBalancerPolicyCommandError(output, context);
+        return de_DeleteLoadBalancerPolicyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDeleteLoadBalancerPolicyOutput(data.DeleteLoadBalancerPolicyResult, context);
+    contents = de_DeleteLoadBalancerPolicyOutput(data.DeleteLoadBalancerPolicyResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDeleteLoadBalancerPolicyCommandError = async (output, context) => {
+const de_DeleteLoadBalancerPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -826,10 +826,10 @@ const deserializeAws_queryDeleteLoadBalancerPolicyCommandError = async (output,
     switch (errorCode) {
         case "InvalidConfigurationRequest":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -840,20 +840,20 @@ const deserializeAws_queryDeleteLoadBalancerPolicyCommandError = async (output,
             });
     }
 };
-export const deserializeAws_queryDeregisterInstancesFromLoadBalancerCommand = async (output, context) => {
+export const de_DeregisterInstancesFromLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDeregisterInstancesFromLoadBalancerCommandError(output, context);
+        return de_DeregisterInstancesFromLoadBalancerCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDeregisterEndPointsOutput(data.DeregisterInstancesFromLoadBalancerResult, context);
+    contents = de_DeregisterEndPointsOutput(data.DeregisterInstancesFromLoadBalancerResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDeregisterInstancesFromLoadBalancerCommandError = async (output, context) => {
+const de_DeregisterInstancesFromLoadBalancerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -862,10 +862,10 @@ const deserializeAws_queryDeregisterInstancesFromLoadBalancerCommandError = asyn
     switch (errorCode) {
         case "InvalidInstance":
         case "com.amazonaws.elasticloadbalancing#InvalidEndPointException":
-            throw await deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context);
+            throw await de_InvalidEndPointExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -876,20 +876,20 @@ const deserializeAws_queryDeregisterInstancesFromLoadBalancerCommandError = asyn
             });
     }
 };
-export const deserializeAws_queryDescribeAccountLimitsCommand = async (output, context) => {
+export const de_DescribeAccountLimitsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeAccountLimitsCommandError(output, context);
+        return de_DescribeAccountLimitsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeAccountLimitsOutput(data.DescribeAccountLimitsResult, context);
+    contents = de_DescribeAccountLimitsOutput(data.DescribeAccountLimitsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeAccountLimitsCommandError = async (output, context) => {
+const de_DescribeAccountLimitsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -903,20 +903,20 @@ const deserializeAws_queryDescribeAccountLimitsCommandError = async (output, con
         errorCode,
     });
 };
-export const deserializeAws_queryDescribeInstanceHealthCommand = async (output, context) => {
+export const de_DescribeInstanceHealthCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeInstanceHealthCommandError(output, context);
+        return de_DescribeInstanceHealthCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeEndPointStateOutput(data.DescribeInstanceHealthResult, context);
+    contents = de_DescribeEndPointStateOutput(data.DescribeInstanceHealthResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeInstanceHealthCommandError = async (output, context) => {
+const de_DescribeInstanceHealthCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -925,10 +925,10 @@ const deserializeAws_queryDescribeInstanceHealthCommandError = async (output, co
     switch (errorCode) {
         case "InvalidInstance":
         case "com.amazonaws.elasticloadbalancing#InvalidEndPointException":
-            throw await deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context);
+            throw await de_InvalidEndPointExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -939,20 +939,20 @@ const deserializeAws_queryDescribeInstanceHealthCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_queryDescribeLoadBalancerAttributesCommand = async (output, context) => {
+export const de_DescribeLoadBalancerAttributesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeLoadBalancerAttributesCommandError(output, context);
+        return de_DescribeLoadBalancerAttributesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeLoadBalancerAttributesOutput(data.DescribeLoadBalancerAttributesResult, context);
+    contents = de_DescribeLoadBalancerAttributesOutput(data.DescribeLoadBalancerAttributesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeLoadBalancerAttributesCommandError = async (output, context) => {
+const de_DescribeLoadBalancerAttributesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -961,10 +961,10 @@ const deserializeAws_queryDescribeLoadBalancerAttributesCommandError = async (ou
     switch (errorCode) {
         case "LoadBalancerAttributeNotFound":
         case "com.amazonaws.elasticloadbalancing#LoadBalancerAttributeNotFoundException":
-            throw await deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_LoadBalancerAttributeNotFoundExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -975,20 +975,20 @@ const deserializeAws_queryDescribeLoadBalancerAttributesCommandError = async (ou
             });
     }
 };
-export const deserializeAws_queryDescribeLoadBalancerPoliciesCommand = async (output, context) => {
+export const de_DescribeLoadBalancerPoliciesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeLoadBalancerPoliciesCommandError(output, context);
+        return de_DescribeLoadBalancerPoliciesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeLoadBalancerPoliciesOutput(data.DescribeLoadBalancerPoliciesResult, context);
+    contents = de_DescribeLoadBalancerPoliciesOutput(data.DescribeLoadBalancerPoliciesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeLoadBalancerPoliciesCommandError = async (output, context) => {
+const de_DescribeLoadBalancerPoliciesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -997,10 +997,10 @@ const deserializeAws_queryDescribeLoadBalancerPoliciesCommandError = async (outp
     switch (errorCode) {
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         case "PolicyNotFound":
         case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException":
-            throw await deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PolicyNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1011,20 +1011,20 @@ const deserializeAws_queryDescribeLoadBalancerPoliciesCommandError = async (outp
             });
     }
 };
-export const deserializeAws_queryDescribeLoadBalancerPolicyTypesCommand = async (output, context) => {
+export const de_DescribeLoadBalancerPolicyTypesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeLoadBalancerPolicyTypesCommandError(output, context);
+        return de_DescribeLoadBalancerPolicyTypesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeLoadBalancerPolicyTypesOutput(data.DescribeLoadBalancerPolicyTypesResult, context);
+    contents = de_DescribeLoadBalancerPolicyTypesOutput(data.DescribeLoadBalancerPolicyTypesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeLoadBalancerPolicyTypesCommandError = async (output, context) => {
+const de_DescribeLoadBalancerPolicyTypesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1033,7 +1033,7 @@ const deserializeAws_queryDescribeLoadBalancerPolicyTypesCommandError = async (o
     switch (errorCode) {
         case "PolicyTypeNotFound":
         case "com.amazonaws.elasticloadbalancing#PolicyTypeNotFoundException":
-            throw await deserializeAws_queryPolicyTypeNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PolicyTypeNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1044,20 +1044,20 @@ const deserializeAws_queryDescribeLoadBalancerPolicyTypesCommandError = async (o
             });
     }
 };
-export const deserializeAws_queryDescribeLoadBalancersCommand = async (output, context) => {
+export const de_DescribeLoadBalancersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeLoadBalancersCommandError(output, context);
+        return de_DescribeLoadBalancersCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeAccessPointsOutput(data.DescribeLoadBalancersResult, context);
+    contents = de_DescribeAccessPointsOutput(data.DescribeLoadBalancersResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeLoadBalancersCommandError = async (output, context) => {
+const de_DescribeLoadBalancersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1066,10 +1066,10 @@ const deserializeAws_queryDescribeLoadBalancersCommandError = async (output, con
     switch (errorCode) {
         case "DependencyThrottle":
         case "com.amazonaws.elasticloadbalancing#DependencyThrottleException":
-            throw await deserializeAws_queryDependencyThrottleExceptionResponse(parsedOutput, context);
+            throw await de_DependencyThrottleExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1080,20 +1080,20 @@ const deserializeAws_queryDescribeLoadBalancersCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_queryDescribeTagsCommand = async (output, context) => {
+export const de_DescribeTagsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDescribeTagsCommandError(output, context);
+        return de_DescribeTagsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDescribeTagsOutput(data.DescribeTagsResult, context);
+    contents = de_DescribeTagsOutput(data.DescribeTagsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDescribeTagsCommandError = async (output, context) => {
+const de_DescribeTagsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1102,7 +1102,7 @@ const deserializeAws_queryDescribeTagsCommandError = async (output, context) =>
     switch (errorCode) {
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1113,20 +1113,20 @@ const deserializeAws_queryDescribeTagsCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_queryDetachLoadBalancerFromSubnetsCommand = async (output, context) => {
+export const de_DetachLoadBalancerFromSubnetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDetachLoadBalancerFromSubnetsCommandError(output, context);
+        return de_DetachLoadBalancerFromSubnetsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryDetachLoadBalancerFromSubnetsOutput(data.DetachLoadBalancerFromSubnetsResult, context);
+    contents = de_DetachLoadBalancerFromSubnetsOutput(data.DetachLoadBalancerFromSubnetsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDetachLoadBalancerFromSubnetsCommandError = async (output, context) => {
+const de_DetachLoadBalancerFromSubnetsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1135,10 +1135,10 @@ const deserializeAws_queryDetachLoadBalancerFromSubnetsCommandError = async (out
     switch (errorCode) {
         case "InvalidConfigurationRequest":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1149,20 +1149,20 @@ const deserializeAws_queryDetachLoadBalancerFromSubnetsCommandError = async (out
             });
     }
 };
-export const deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommand = async (output, context) => {
+export const de_DisableAvailabilityZonesForLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommandError(output, context);
+        return de_DisableAvailabilityZonesForLoadBalancerCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryRemoveAvailabilityZonesOutput(data.DisableAvailabilityZonesForLoadBalancerResult, context);
+    contents = de_RemoveAvailabilityZonesOutput(data.DisableAvailabilityZonesForLoadBalancerResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommandError = async (output, context) => {
+const de_DisableAvailabilityZonesForLoadBalancerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1171,10 +1171,10 @@ const deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommandError =
     switch (errorCode) {
         case "InvalidConfigurationRequest":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1185,20 +1185,20 @@ const deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommandError =
             });
     }
 };
-export const deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommand = async (output, context) => {
+export const de_EnableAvailabilityZonesForLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommandError(output, context);
+        return de_EnableAvailabilityZonesForLoadBalancerCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryAddAvailabilityZonesOutput(data.EnableAvailabilityZonesForLoadBalancerResult, context);
+    contents = de_AddAvailabilityZonesOutput(data.EnableAvailabilityZonesForLoadBalancerResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommandError = async (output, context) => {
+const de_EnableAvailabilityZonesForLoadBalancerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1207,7 +1207,7 @@ const deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommandError = a
     switch (errorCode) {
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1218,20 +1218,20 @@ const deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommandError = a
             });
     }
 };
-export const deserializeAws_queryModifyLoadBalancerAttributesCommand = async (output, context) => {
+export const de_ModifyLoadBalancerAttributesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryModifyLoadBalancerAttributesCommandError(output, context);
+        return de_ModifyLoadBalancerAttributesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryModifyLoadBalancerAttributesOutput(data.ModifyLoadBalancerAttributesResult, context);
+    contents = de_ModifyLoadBalancerAttributesOutput(data.ModifyLoadBalancerAttributesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryModifyLoadBalancerAttributesCommandError = async (output, context) => {
+const de_ModifyLoadBalancerAttributesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1240,13 +1240,13 @@ const deserializeAws_queryModifyLoadBalancerAttributesCommandError = async (outp
     switch (errorCode) {
         case "InvalidConfigurationRequest":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
         case "LoadBalancerAttributeNotFound":
         case "com.amazonaws.elasticloadbalancing#LoadBalancerAttributeNotFoundException":
-            throw await deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_LoadBalancerAttributeNotFoundExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1257,20 +1257,20 @@ const deserializeAws_queryModifyLoadBalancerAttributesCommandError = async (outp
             });
     }
 };
-export const deserializeAws_queryRegisterInstancesWithLoadBalancerCommand = async (output, context) => {
+export const de_RegisterInstancesWithLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryRegisterInstancesWithLoadBalancerCommandError(output, context);
+        return de_RegisterInstancesWithLoadBalancerCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryRegisterEndPointsOutput(data.RegisterInstancesWithLoadBalancerResult, context);
+    contents = de_RegisterEndPointsOutput(data.RegisterInstancesWithLoadBalancerResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryRegisterInstancesWithLoadBalancerCommandError = async (output, context) => {
+const de_RegisterInstancesWithLoadBalancerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1279,10 +1279,10 @@ const deserializeAws_queryRegisterInstancesWithLoadBalancerCommandError = async
     switch (errorCode) {
         case "InvalidInstance":
         case "com.amazonaws.elasticloadbalancing#InvalidEndPointException":
-            throw await deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context);
+            throw await de_InvalidEndPointExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1293,20 +1293,20 @@ const deserializeAws_queryRegisterInstancesWithLoadBalancerCommandError = async
             });
     }
 };
-export const deserializeAws_queryRemoveTagsCommand = async (output, context) => {
+export const de_RemoveTagsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_queryRemoveTagsCommandError(output, context);
+        return de_RemoveTagsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_queryRemoveTagsOutput(data.RemoveTagsResult, context);
+    contents = de_RemoveTagsOutput(data.RemoveTagsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_queryRemoveTagsCommandError = async (output, context) => {
+const de_RemoveTagsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1315,7 +1315,7 @@ const deserializeAws_queryRemoveTagsCommandError = async (output, context) => {
     switch (errorCode) {
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1326,20 +1326,20 @@ const deserializeAws_queryRemoveTagsCommandError = async (output, context) => {
             });
     }
 };
-export const deserializeAws_querySetLoadBalancerListenerSSLCertificateCommand = async (output, context) => {
+export const de_SetLoadBalancerListenerSSLCertificateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_querySetLoadBalancerListenerSSLCertificateCommandError(output, context);
+        return de_SetLoadBalancerListenerSSLCertificateCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_querySetLoadBalancerListenerSSLCertificateOutput(data.SetLoadBalancerListenerSSLCertificateResult, context);
+    contents = de_SetLoadBalancerListenerSSLCertificateOutput(data.SetLoadBalancerListenerSSLCertificateResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_querySetLoadBalancerListenerSSLCertificateCommandError = async (output, context) => {
+const de_SetLoadBalancerListenerSSLCertificateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1348,19 +1348,19 @@ const deserializeAws_querySetLoadBalancerListenerSSLCertificateCommandError = as
     switch (errorCode) {
         case "CertificateNotFound":
         case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException":
-            throw await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_CertificateNotFoundExceptionRes(parsedOutput, context);
         case "InvalidConfigurationRequest":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
         case "ListenerNotFound":
         case "com.amazonaws.elasticloadbalancing#ListenerNotFoundException":
-            throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         case "UnsupportedProtocol":
         case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException":
-            throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedProtocolExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1371,20 +1371,20 @@ const deserializeAws_querySetLoadBalancerListenerSSLCertificateCommandError = as
             });
     }
 };
-export const deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommand = async (output, context) => {
+export const de_SetLoadBalancerPoliciesForBackendServerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommandError(output, context);
+        return de_SetLoadBalancerPoliciesForBackendServerCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_querySetLoadBalancerPoliciesForBackendServerOutput(data.SetLoadBalancerPoliciesForBackendServerResult, context);
+    contents = de_SetLoadBalancerPoliciesForBackendServerOutput(data.SetLoadBalancerPoliciesForBackendServerResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommandError = async (output, context) => {
+const de_SetLoadBalancerPoliciesForBackendServerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1393,13 +1393,13 @@ const deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommandError =
     switch (errorCode) {
         case "InvalidConfigurationRequest":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         case "PolicyNotFound":
         case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException":
-            throw await deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PolicyNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1410,20 +1410,20 @@ const deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommandError =
             });
     }
 };
-export const deserializeAws_querySetLoadBalancerPoliciesOfListenerCommand = async (output, context) => {
+export const de_SetLoadBalancerPoliciesOfListenerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_querySetLoadBalancerPoliciesOfListenerCommandError(output, context);
+        return de_SetLoadBalancerPoliciesOfListenerCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_querySetLoadBalancerPoliciesOfListenerOutput(data.SetLoadBalancerPoliciesOfListenerResult, context);
+    contents = de_SetLoadBalancerPoliciesOfListenerOutput(data.SetLoadBalancerPoliciesOfListenerResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_querySetLoadBalancerPoliciesOfListenerCommandError = async (output, context) => {
+const de_SetLoadBalancerPoliciesOfListenerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1432,16 +1432,16 @@ const deserializeAws_querySetLoadBalancerPoliciesOfListenerCommandError = async
     switch (errorCode) {
         case "InvalidConfigurationRequest":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
+            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
         case "ListenerNotFound":
         case "com.amazonaws.elasticloadbalancing#ListenerNotFoundException":
-            throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
         case "PolicyNotFound":
         case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException":
-            throw await deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_PolicyNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1452,205 +1452,205 @@ const deserializeAws_querySetLoadBalancerPoliciesOfListenerCommandError = async
             });
     }
 };
-const deserializeAws_queryAccessPointNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_AccessPointNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryAccessPointNotFoundException(body.Error, context);
+    const deserialized = de_AccessPointNotFoundException(body.Error, context);
     const exception = new AccessPointNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryCertificateNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_CertificateNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryCertificateNotFoundException(body.Error, context);
+    const deserialized = de_CertificateNotFoundException(body.Error, context);
     const exception = new CertificateNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryDependencyThrottleExceptionResponse = async (parsedOutput, context) => {
+const de_DependencyThrottleExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryDependencyThrottleException(body.Error, context);
+    const deserialized = de_DependencyThrottleException(body.Error, context);
     const exception = new DependencyThrottleException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryDuplicateAccessPointNameExceptionResponse = async (parsedOutput, context) => {
+const de_DuplicateAccessPointNameExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryDuplicateAccessPointNameException(body.Error, context);
+    const deserialized = de_DuplicateAccessPointNameException(body.Error, context);
     const exception = new DuplicateAccessPointNameException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryDuplicateListenerExceptionResponse = async (parsedOutput, context) => {
+const de_DuplicateListenerExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryDuplicateListenerException(body.Error, context);
+    const deserialized = de_DuplicateListenerException(body.Error, context);
     const exception = new DuplicateListenerException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryDuplicatePolicyNameExceptionResponse = async (parsedOutput, context) => {
+const de_DuplicatePolicyNameExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryDuplicatePolicyNameException(body.Error, context);
+    const deserialized = de_DuplicatePolicyNameException(body.Error, context);
     const exception = new DuplicatePolicyNameException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryDuplicateTagKeysExceptionResponse = async (parsedOutput, context) => {
+const de_DuplicateTagKeysExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryDuplicateTagKeysException(body.Error, context);
+    const deserialized = de_DuplicateTagKeysException(body.Error, context);
     const exception = new DuplicateTagKeysException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryInvalidConfigurationRequestExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidConfigurationRequestExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidConfigurationRequestException(body.Error, context);
+    const deserialized = de_InvalidConfigurationRequestException(body.Error, context);
     const exception = new InvalidConfigurationRequestException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryInvalidEndPointExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidEndPointExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidEndPointException(body.Error, context);
+    const deserialized = de_InvalidEndPointException(body.Error, context);
     const exception = new InvalidEndPointException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryInvalidSchemeExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidSchemeExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidSchemeException(body.Error, context);
+    const deserialized = de_InvalidSchemeException(body.Error, context);
     const exception = new InvalidSchemeException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryInvalidSecurityGroupExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidSecurityGroupExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidSecurityGroupException(body.Error, context);
+    const deserialized = de_InvalidSecurityGroupException(body.Error, context);
     const exception = new InvalidSecurityGroupException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryInvalidSubnetExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidSubnetExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryInvalidSubnetException(body.Error, context);
+    const deserialized = de_InvalidSubnetException(body.Error, context);
     const exception = new InvalidSubnetException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryListenerNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_ListenerNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryListenerNotFoundException(body.Error, context);
+    const deserialized = de_ListenerNotFoundException(body.Error, context);
     const exception = new ListenerNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_LoadBalancerAttributeNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryLoadBalancerAttributeNotFoundException(body.Error, context);
+    const deserialized = de_LoadBalancerAttributeNotFoundException(body.Error, context);
     const exception = new LoadBalancerAttributeNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryOperationNotPermittedExceptionResponse = async (parsedOutput, context) => {
+const de_OperationNotPermittedExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryOperationNotPermittedException(body.Error, context);
+    const deserialized = de_OperationNotPermittedException(body.Error, context);
     const exception = new OperationNotPermittedException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryPolicyNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_PolicyNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryPolicyNotFoundException(body.Error, context);
+    const deserialized = de_PolicyNotFoundException(body.Error, context);
     const exception = new PolicyNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryPolicyTypeNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_PolicyTypeNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryPolicyTypeNotFoundException(body.Error, context);
+    const deserialized = de_PolicyTypeNotFoundException(body.Error, context);
     const exception = new PolicyTypeNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_querySubnetNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_SubnetNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_querySubnetNotFoundException(body.Error, context);
+    const deserialized = de_SubnetNotFoundException(body.Error, context);
     const exception = new SubnetNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryTooManyAccessPointsExceptionResponse = async (parsedOutput, context) => {
+const de_TooManyAccessPointsExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryTooManyAccessPointsException(body.Error, context);
+    const deserialized = de_TooManyAccessPointsException(body.Error, context);
     const exception = new TooManyAccessPointsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryTooManyPoliciesExceptionResponse = async (parsedOutput, context) => {
+const de_TooManyPoliciesExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryTooManyPoliciesException(body.Error, context);
+    const deserialized = de_TooManyPoliciesException(body.Error, context);
     const exception = new TooManyPoliciesException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryTooManyTagsExceptionResponse = async (parsedOutput, context) => {
+const de_TooManyTagsExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryTooManyTagsException(body.Error, context);
+    const deserialized = de_TooManyTagsException(body.Error, context);
     const exception = new TooManyTagsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_queryUnsupportedProtocolExceptionResponse = async (parsedOutput, context) => {
+const de_UnsupportedProtocolExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_queryUnsupportedProtocolException(body.Error, context);
+    const deserialized = de_UnsupportedProtocolException(body.Error, context);
     const exception = new UnsupportedProtocolException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const serializeAws_queryAccessLog = (input, context) => {
+const se_AccessLog = (input, context) => {
     const entries = {};
     if (input.Enabled != null) {
         entries["Enabled"] = input.Enabled;
@@ -1666,13 +1666,13 @@ const serializeAws_queryAccessLog = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryAddAvailabilityZonesInput = (input, context) => {
+const se_AddAvailabilityZonesInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
     }
     if (input.AvailabilityZones != null) {
-        const memberEntries = serializeAws_queryAvailabilityZones(input.AvailabilityZones, context);
+        const memberEntries = se_AvailabilityZones(input.AvailabilityZones, context);
         if (input.AvailabilityZones?.length === 0) {
             entries.AvailabilityZones = [];
         }
@@ -1683,7 +1683,7 @@ const serializeAws_queryAddAvailabilityZonesInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryAdditionalAttribute = (input, context) => {
+const se_AdditionalAttribute = (input, context) => {
     const entries = {};
     if (input.Key != null) {
         entries["Key"] = input.Key;
@@ -1693,14 +1693,14 @@ const serializeAws_queryAdditionalAttribute = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryAdditionalAttributes = (input, context) => {
+const se_AdditionalAttributes = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryAdditionalAttribute(entry, context);
+        const memberEntries = se_AdditionalAttribute(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -1708,10 +1708,10 @@ const serializeAws_queryAdditionalAttributes = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryAddTagsInput = (input, context) => {
+const se_AddTagsInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerNames != null) {
-        const memberEntries = serializeAws_queryLoadBalancerNames(input.LoadBalancerNames, context);
+        const memberEntries = se_LoadBalancerNames(input.LoadBalancerNames, context);
         if (input.LoadBalancerNames?.length === 0) {
             entries.LoadBalancerNames = [];
         }
@@ -1721,7 +1721,7 @@ const serializeAws_queryAddTagsInput = (input, context) => {
         });
     }
     if (input.Tags != null) {
-        const memberEntries = serializeAws_queryTagList(input.Tags, context);
+        const memberEntries = se_TagList(input.Tags, context);
         if (input.Tags?.length === 0) {
             entries.Tags = [];
         }
@@ -1732,13 +1732,13 @@ const serializeAws_queryAddTagsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryApplySecurityGroupsToLoadBalancerInput = (input, context) => {
+const se_ApplySecurityGroupsToLoadBalancerInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
     }
     if (input.SecurityGroups != null) {
-        const memberEntries = serializeAws_querySecurityGroups(input.SecurityGroups, context);
+        const memberEntries = se_SecurityGroups(input.SecurityGroups, context);
         if (input.SecurityGroups?.length === 0) {
             entries.SecurityGroups = [];
         }
@@ -1749,13 +1749,13 @@ const serializeAws_queryApplySecurityGroupsToLoadBalancerInput = (input, context
     }
     return entries;
 };
-const serializeAws_queryAttachLoadBalancerToSubnetsInput = (input, context) => {
+const se_AttachLoadBalancerToSubnetsInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
     }
     if (input.Subnets != null) {
-        const memberEntries = serializeAws_querySubnets(input.Subnets, context);
+        const memberEntries = se_Subnets(input.Subnets, context);
         if (input.Subnets?.length === 0) {
             entries.Subnets = [];
         }
@@ -1766,7 +1766,7 @@ const serializeAws_queryAttachLoadBalancerToSubnetsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryAvailabilityZones = (input, context) => {
+const se_AvailabilityZones = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -1778,13 +1778,13 @@ const serializeAws_queryAvailabilityZones = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryConfigureHealthCheckInput = (input, context) => {
+const se_ConfigureHealthCheckInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
     }
     if (input.HealthCheck != null) {
-        const memberEntries = serializeAws_queryHealthCheck(input.HealthCheck, context);
+        const memberEntries = se_HealthCheck(input.HealthCheck, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `HealthCheck.${key}`;
             entries[loc] = value;
@@ -1792,7 +1792,7 @@ const serializeAws_queryConfigureHealthCheckInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryConnectionDraining = (input, context) => {
+const se_ConnectionDraining = (input, context) => {
     const entries = {};
     if (input.Enabled != null) {
         entries["Enabled"] = input.Enabled;
@@ -1802,20 +1802,20 @@ const serializeAws_queryConnectionDraining = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryConnectionSettings = (input, context) => {
+const se_ConnectionSettings = (input, context) => {
     const entries = {};
     if (input.IdleTimeout != null) {
         entries["IdleTimeout"] = input.IdleTimeout;
     }
     return entries;
 };
-const serializeAws_queryCreateAccessPointInput = (input, context) => {
+const se_CreateAccessPointInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
     }
     if (input.Listeners != null) {
-        const memberEntries = serializeAws_queryListeners(input.Listeners, context);
+        const memberEntries = se_Listeners(input.Listeners, context);
         if (input.Listeners?.length === 0) {
             entries.Listeners = [];
         }
@@ -1825,7 +1825,7 @@ const serializeAws_queryCreateAccessPointInput = (input, context) => {
         });
     }
     if (input.AvailabilityZones != null) {
-        const memberEntries = serializeAws_queryAvailabilityZones(input.AvailabilityZones, context);
+        const memberEntries = se_AvailabilityZones(input.AvailabilityZones, context);
         if (input.AvailabilityZones?.length === 0) {
             entries.AvailabilityZones = [];
         }
@@ -1835,7 +1835,7 @@ const serializeAws_queryCreateAccessPointInput = (input, context) => {
         });
     }
     if (input.Subnets != null) {
-        const memberEntries = serializeAws_querySubnets(input.Subnets, context);
+        const memberEntries = se_Subnets(input.Subnets, context);
         if (input.Subnets?.length === 0) {
             entries.Subnets = [];
         }
@@ -1845,7 +1845,7 @@ const serializeAws_queryCreateAccessPointInput = (input, context) => {
         });
     }
     if (input.SecurityGroups != null) {
-        const memberEntries = serializeAws_querySecurityGroups(input.SecurityGroups, context);
+        const memberEntries = se_SecurityGroups(input.SecurityGroups, context);
         if (input.SecurityGroups?.length === 0) {
             entries.SecurityGroups = [];
         }
@@ -1858,7 +1858,7 @@ const serializeAws_queryCreateAccessPointInput = (input, context) => {
         entries["Scheme"] = input.Scheme;
     }
     if (input.Tags != null) {
-        const memberEntries = serializeAws_queryTagList(input.Tags, context);
+        const memberEntries = se_TagList(input.Tags, context);
         if (input.Tags?.length === 0) {
             entries.Tags = [];
         }
@@ -1869,7 +1869,7 @@ const serializeAws_queryCreateAccessPointInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryCreateAppCookieStickinessPolicyInput = (input, context) => {
+const se_CreateAppCookieStickinessPolicyInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
@@ -1882,7 +1882,7 @@ const serializeAws_queryCreateAppCookieStickinessPolicyInput = (input, context)
     }
     return entries;
 };
-const serializeAws_queryCreateLBCookieStickinessPolicyInput = (input, context) => {
+const se_CreateLBCookieStickinessPolicyInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
@@ -1895,13 +1895,13 @@ const serializeAws_queryCreateLBCookieStickinessPolicyInput = (input, context) =
     }
     return entries;
 };
-const serializeAws_queryCreateLoadBalancerListenerInput = (input, context) => {
+const se_CreateLoadBalancerListenerInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
     }
     if (input.Listeners != null) {
-        const memberEntries = serializeAws_queryListeners(input.Listeners, context);
+        const memberEntries = se_Listeners(input.Listeners, context);
         if (input.Listeners?.length === 0) {
             entries.Listeners = [];
         }
@@ -1912,7 +1912,7 @@ const serializeAws_queryCreateLoadBalancerListenerInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryCreateLoadBalancerPolicyInput = (input, context) => {
+const se_CreateLoadBalancerPolicyInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
@@ -1924,7 +1924,7 @@ const serializeAws_queryCreateLoadBalancerPolicyInput = (input, context) => {
         entries["PolicyTypeName"] = input.PolicyTypeName;
     }
     if (input.PolicyAttributes != null) {
-        const memberEntries = serializeAws_queryPolicyAttributes(input.PolicyAttributes, context);
+        const memberEntries = se_PolicyAttributes(input.PolicyAttributes, context);
         if (input.PolicyAttributes?.length === 0) {
             entries.PolicyAttributes = [];
         }
@@ -1935,27 +1935,27 @@ const serializeAws_queryCreateLoadBalancerPolicyInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryCrossZoneLoadBalancing = (input, context) => {
+const se_CrossZoneLoadBalancing = (input, context) => {
     const entries = {};
     if (input.Enabled != null) {
         entries["Enabled"] = input.Enabled;
     }
     return entries;
 };
-const serializeAws_queryDeleteAccessPointInput = (input, context) => {
+const se_DeleteAccessPointInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
     }
     return entries;
 };
-const serializeAws_queryDeleteLoadBalancerListenerInput = (input, context) => {
+const se_DeleteLoadBalancerListenerInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
     }
     if (input.LoadBalancerPorts != null) {
-        const memberEntries = serializeAws_queryPorts(input.LoadBalancerPorts, context);
+        const memberEntries = se_Ports(input.LoadBalancerPorts, context);
         if (input.LoadBalancerPorts?.length === 0) {
             entries.LoadBalancerPorts = [];
         }
@@ -1966,7 +1966,7 @@ const serializeAws_queryDeleteLoadBalancerListenerInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeleteLoadBalancerPolicyInput = (input, context) => {
+const se_DeleteLoadBalancerPolicyInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
@@ -1976,13 +1976,13 @@ const serializeAws_queryDeleteLoadBalancerPolicyInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDeregisterEndPointsInput = (input, context) => {
+const se_DeregisterEndPointsInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
     }
     if (input.Instances != null) {
-        const memberEntries = serializeAws_queryInstances(input.Instances, context);
+        const memberEntries = se_Instances(input.Instances, context);
         if (input.Instances?.length === 0) {
             entries.Instances = [];
         }
@@ -1993,10 +1993,10 @@ const serializeAws_queryDeregisterEndPointsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDescribeAccessPointsInput = (input, context) => {
+const se_DescribeAccessPointsInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerNames != null) {
-        const memberEntries = serializeAws_queryLoadBalancerNames(input.LoadBalancerNames, context);
+        const memberEntries = se_LoadBalancerNames(input.LoadBalancerNames, context);
         if (input.LoadBalancerNames?.length === 0) {
             entries.LoadBalancerNames = [];
         }
@@ -2013,7 +2013,7 @@ const serializeAws_queryDescribeAccessPointsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDescribeAccountLimitsInput = (input, context) => {
+const se_DescribeAccountLimitsInput = (input, context) => {
     const entries = {};
     if (input.Marker != null) {
         entries["Marker"] = input.Marker;
@@ -2023,13 +2023,13 @@ const serializeAws_queryDescribeAccountLimitsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDescribeEndPointStateInput = (input, context) => {
+const se_DescribeEndPointStateInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
     }
     if (input.Instances != null) {
-        const memberEntries = serializeAws_queryInstances(input.Instances, context);
+        const memberEntries = se_Instances(input.Instances, context);
         if (input.Instances?.length === 0) {
             entries.Instances = [];
         }
@@ -2040,20 +2040,20 @@ const serializeAws_queryDescribeEndPointStateInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDescribeLoadBalancerAttributesInput = (input, context) => {
+const se_DescribeLoadBalancerAttributesInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
     }
     return entries;
 };
-const serializeAws_queryDescribeLoadBalancerPoliciesInput = (input, context) => {
+const se_DescribeLoadBalancerPoliciesInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
     }
     if (input.PolicyNames != null) {
-        const memberEntries = serializeAws_queryPolicyNames(input.PolicyNames, context);
+        const memberEntries = se_PolicyNames(input.PolicyNames, context);
         if (input.PolicyNames?.length === 0) {
             entries.PolicyNames = [];
         }
@@ -2064,10 +2064,10 @@ const serializeAws_queryDescribeLoadBalancerPoliciesInput = (input, context) =>
     }
     return entries;
 };
-const serializeAws_queryDescribeLoadBalancerPolicyTypesInput = (input, context) => {
+const se_DescribeLoadBalancerPolicyTypesInput = (input, context) => {
     const entries = {};
     if (input.PolicyTypeNames != null) {
-        const memberEntries = serializeAws_queryPolicyTypeNames(input.PolicyTypeNames, context);
+        const memberEntries = se_PolicyTypeNames(input.PolicyTypeNames, context);
         if (input.PolicyTypeNames?.length === 0) {
             entries.PolicyTypeNames = [];
         }
@@ -2078,10 +2078,10 @@ const serializeAws_queryDescribeLoadBalancerPolicyTypesInput = (input, context)
     }
     return entries;
 };
-const serializeAws_queryDescribeTagsInput = (input, context) => {
+const se_DescribeTagsInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerNames != null) {
-        const memberEntries = serializeAws_queryLoadBalancerNamesMax20(input.LoadBalancerNames, context);
+        const memberEntries = se_LoadBalancerNamesMax20(input.LoadBalancerNames, context);
         if (input.LoadBalancerNames?.length === 0) {
             entries.LoadBalancerNames = [];
         }
@@ -2092,13 +2092,13 @@ const serializeAws_queryDescribeTagsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDetachLoadBalancerFromSubnetsInput = (input, context) => {
+const se_DetachLoadBalancerFromSubnetsInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
     }
     if (input.Subnets != null) {
-        const memberEntries = serializeAws_querySubnets(input.Subnets, context);
+        const memberEntries = se_Subnets(input.Subnets, context);
         if (input.Subnets?.length === 0) {
             entries.Subnets = [];
         }
@@ -2109,7 +2109,7 @@ const serializeAws_queryDetachLoadBalancerFromSubnetsInput = (input, context) =>
     }
     return entries;
 };
-const serializeAws_queryHealthCheck = (input, context) => {
+const se_HealthCheck = (input, context) => {
     const entries = {};
     if (input.Target != null) {
         entries["Target"] = input.Target;
@@ -2128,21 +2128,21 @@ const serializeAws_queryHealthCheck = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryInstance = (input, context) => {
+const se_Instance = (input, context) => {
     const entries = {};
     if (input.InstanceId != null) {
         entries["InstanceId"] = input.InstanceId;
     }
     return entries;
 };
-const serializeAws_queryInstances = (input, context) => {
+const se_Instances = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryInstance(entry, context);
+        const memberEntries = se_Instance(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -2150,7 +2150,7 @@ const serializeAws_queryInstances = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryListener = (input, context) => {
+const se_Listener = (input, context) => {
     const entries = {};
     if (input.Protocol != null) {
         entries["Protocol"] = input.Protocol;
@@ -2169,14 +2169,14 @@ const serializeAws_queryListener = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryListeners = (input, context) => {
+const se_Listeners = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryListener(entry, context);
+        const memberEntries = se_Listener(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -2184,38 +2184,38 @@ const serializeAws_queryListeners = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryLoadBalancerAttributes = (input, context) => {
+const se_LoadBalancerAttributes = (input, context) => {
     const entries = {};
     if (input.CrossZoneLoadBalancing != null) {
-        const memberEntries = serializeAws_queryCrossZoneLoadBalancing(input.CrossZoneLoadBalancing, context);
+        const memberEntries = se_CrossZoneLoadBalancing(input.CrossZoneLoadBalancing, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `CrossZoneLoadBalancing.${key}`;
             entries[loc] = value;
         });
     }
     if (input.AccessLog != null) {
-        const memberEntries = serializeAws_queryAccessLog(input.AccessLog, context);
+        const memberEntries = se_AccessLog(input.AccessLog, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `AccessLog.${key}`;
             entries[loc] = value;
         });
     }
     if (input.ConnectionDraining != null) {
-        const memberEntries = serializeAws_queryConnectionDraining(input.ConnectionDraining, context);
+        const memberEntries = se_ConnectionDraining(input.ConnectionDraining, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `ConnectionDraining.${key}`;
             entries[loc] = value;
         });
     }
     if (input.ConnectionSettings != null) {
-        const memberEntries = serializeAws_queryConnectionSettings(input.ConnectionSettings, context);
+        const memberEntries = se_ConnectionSettings(input.ConnectionSettings, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `ConnectionSettings.${key}`;
             entries[loc] = value;
         });
     }
     if (input.AdditionalAttributes != null) {
-        const memberEntries = serializeAws_queryAdditionalAttributes(input.AdditionalAttributes, context);
+        const memberEntries = se_AdditionalAttributes(input.AdditionalAttributes, context);
         if (input.AdditionalAttributes?.length === 0) {
             entries.AdditionalAttributes = [];
         }
@@ -2226,7 +2226,7 @@ const serializeAws_queryLoadBalancerAttributes = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryLoadBalancerNames = (input, context) => {
+const se_LoadBalancerNames = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -2238,7 +2238,7 @@ const serializeAws_queryLoadBalancerNames = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryLoadBalancerNamesMax20 = (input, context) => {
+const se_LoadBalancerNamesMax20 = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -2250,13 +2250,13 @@ const serializeAws_queryLoadBalancerNamesMax20 = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryModifyLoadBalancerAttributesInput = (input, context) => {
+const se_ModifyLoadBalancerAttributesInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
     }
     if (input.LoadBalancerAttributes != null) {
-        const memberEntries = serializeAws_queryLoadBalancerAttributes(input.LoadBalancerAttributes, context);
+        const memberEntries = se_LoadBalancerAttributes(input.LoadBalancerAttributes, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             const loc = `LoadBalancerAttributes.${key}`;
             entries[loc] = value;
@@ -2264,7 +2264,7 @@ const serializeAws_queryModifyLoadBalancerAttributesInput = (input, context) =>
     }
     return entries;
 };
-const serializeAws_queryPolicyAttribute = (input, context) => {
+const se_PolicyAttribute = (input, context) => {
     const entries = {};
     if (input.AttributeName != null) {
         entries["AttributeName"] = input.AttributeName;
@@ -2274,14 +2274,14 @@ const serializeAws_queryPolicyAttribute = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryPolicyAttributes = (input, context) => {
+const se_PolicyAttributes = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryPolicyAttribute(entry, context);
+        const memberEntries = se_PolicyAttribute(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -2289,7 +2289,7 @@ const serializeAws_queryPolicyAttributes = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryPolicyNames = (input, context) => {
+const se_PolicyNames = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -2301,7 +2301,7 @@ const serializeAws_queryPolicyNames = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryPolicyTypeNames = (input, context) => {
+const se_PolicyTypeNames = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -2313,7 +2313,7 @@ const serializeAws_queryPolicyTypeNames = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryPorts = (input, context) => {
+const se_Ports = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -2325,13 +2325,13 @@ const serializeAws_queryPorts = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryRegisterEndPointsInput = (input, context) => {
+const se_RegisterEndPointsInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
     }
     if (input.Instances != null) {
-        const memberEntries = serializeAws_queryInstances(input.Instances, context);
+        const memberEntries = se_Instances(input.Instances, context);
         if (input.Instances?.length === 0) {
             entries.Instances = [];
         }
@@ -2342,13 +2342,13 @@ const serializeAws_queryRegisterEndPointsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryRemoveAvailabilityZonesInput = (input, context) => {
+const se_RemoveAvailabilityZonesInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
     }
     if (input.AvailabilityZones != null) {
-        const memberEntries = serializeAws_queryAvailabilityZones(input.AvailabilityZones, context);
+        const memberEntries = se_AvailabilityZones(input.AvailabilityZones, context);
         if (input.AvailabilityZones?.length === 0) {
             entries.AvailabilityZones = [];
         }
@@ -2359,10 +2359,10 @@ const serializeAws_queryRemoveAvailabilityZonesInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryRemoveTagsInput = (input, context) => {
+const se_RemoveTagsInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerNames != null) {
-        const memberEntries = serializeAws_queryLoadBalancerNames(input.LoadBalancerNames, context);
+        const memberEntries = se_LoadBalancerNames(input.LoadBalancerNames, context);
         if (input.LoadBalancerNames?.length === 0) {
             entries.LoadBalancerNames = [];
         }
@@ -2372,7 +2372,7 @@ const serializeAws_queryRemoveTagsInput = (input, context) => {
         });
     }
     if (input.Tags != null) {
-        const memberEntries = serializeAws_queryTagKeyList(input.Tags, context);
+        const memberEntries = se_TagKeyList(input.Tags, context);
         if (input.Tags?.length === 0) {
             entries.Tags = [];
         }
@@ -2383,7 +2383,7 @@ const serializeAws_queryRemoveTagsInput = (input, context) => {
     }
     return entries;
 };
-const serializeAws_querySecurityGroups = (input, context) => {
+const se_SecurityGroups = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -2395,7 +2395,7 @@ const serializeAws_querySecurityGroups = (input, context) => {
     }
     return entries;
 };
-const serializeAws_querySetLoadBalancerListenerSSLCertificateInput = (input, context) => {
+const se_SetLoadBalancerListenerSSLCertificateInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
@@ -2408,7 +2408,7 @@ const serializeAws_querySetLoadBalancerListenerSSLCertificateInput = (input, con
     }
     return entries;
 };
-const serializeAws_querySetLoadBalancerPoliciesForBackendServerInput = (input, context) => {
+const se_SetLoadBalancerPoliciesForBackendServerInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
@@ -2417,7 +2417,7 @@ const serializeAws_querySetLoadBalancerPoliciesForBackendServerInput = (input, c
         entries["InstancePort"] = input.InstancePort;
     }
     if (input.PolicyNames != null) {
-        const memberEntries = serializeAws_queryPolicyNames(input.PolicyNames, context);
+        const memberEntries = se_PolicyNames(input.PolicyNames, context);
         if (input.PolicyNames?.length === 0) {
             entries.PolicyNames = [];
         }
@@ -2428,7 +2428,7 @@ const serializeAws_querySetLoadBalancerPoliciesForBackendServerInput = (input, c
     }
     return entries;
 };
-const serializeAws_querySetLoadBalancerPoliciesOfListenerInput = (input, context) => {
+const se_SetLoadBalancerPoliciesOfListenerInput = (input, context) => {
     const entries = {};
     if (input.LoadBalancerName != null) {
         entries["LoadBalancerName"] = input.LoadBalancerName;
@@ -2437,7 +2437,7 @@ const serializeAws_querySetLoadBalancerPoliciesOfListenerInput = (input, context
         entries["LoadBalancerPort"] = input.LoadBalancerPort;
     }
     if (input.PolicyNames != null) {
-        const memberEntries = serializeAws_queryPolicyNames(input.PolicyNames, context);
+        const memberEntries = se_PolicyNames(input.PolicyNames, context);
         if (input.PolicyNames?.length === 0) {
             entries.PolicyNames = [];
         }
@@ -2448,7 +2448,7 @@ const serializeAws_querySetLoadBalancerPoliciesOfListenerInput = (input, context
     }
     return entries;
 };
-const serializeAws_querySubnets = (input, context) => {
+const se_Subnets = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
@@ -2460,7 +2460,7 @@ const serializeAws_querySubnets = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryTag = (input, context) => {
+const se_Tag = (input, context) => {
     const entries = {};
     if (input.Key != null) {
         entries["Key"] = input.Key;
@@ -2470,14 +2470,14 @@ const serializeAws_queryTag = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryTagKeyList = (input, context) => {
+const se_TagKeyList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryTagKeyOnly(entry, context);
+        const memberEntries = se_TagKeyOnly(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -2485,21 +2485,21 @@ const serializeAws_queryTagKeyList = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryTagKeyOnly = (input, context) => {
+const se_TagKeyOnly = (input, context) => {
     const entries = {};
     if (input.Key != null) {
         entries["Key"] = input.Key;
     }
     return entries;
 };
-const serializeAws_queryTagList = (input, context) => {
+const se_TagList = (input, context) => {
     const entries = {};
     let counter = 1;
     for (const entry of input) {
         if (entry === null) {
             continue;
         }
-        const memberEntries = serializeAws_queryTag(entry, context);
+        const memberEntries = se_Tag(entry, context);
         Object.entries(memberEntries).forEach(([key, value]) => {
             entries[`member.${counter}.${key}`] = value;
         });
@@ -2507,7 +2507,7 @@ const serializeAws_queryTagList = (input, context) => {
     }
     return entries;
 };
-const deserializeAws_queryAccessLog = (output, context) => {
+const de_AccessLog = (output, context) => {
     const contents = {};
     if (output["Enabled"] !== undefined) {
         contents.Enabled = __parseBoolean(output["Enabled"]);
@@ -2523,24 +2523,24 @@ const deserializeAws_queryAccessLog = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryAccessPointNotFoundException = (output, context) => {
+const de_AccessPointNotFoundException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryAddAvailabilityZonesOutput = (output, context) => {
+const de_AddAvailabilityZonesOutput = (output, context) => {
     const contents = {};
     if (output.AvailabilityZones === "") {
         contents.AvailabilityZones = [];
     }
     else if (output["AvailabilityZones"] !== undefined && output["AvailabilityZones"]["member"] !== undefined) {
-        contents.AvailabilityZones = deserializeAws_queryAvailabilityZones(__getArrayIfSingleItem(output["AvailabilityZones"]["member"]), context);
+        contents.AvailabilityZones = de_AvailabilityZones(__getArrayIfSingleItem(output["AvailabilityZones"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryAdditionalAttribute = (output, context) => {
+const de_AdditionalAttribute = (output, context) => {
     const contents = {};
     if (output["Key"] !== undefined) {
         contents.Key = __expectString(output["Key"]);
@@ -2550,25 +2550,25 @@ const deserializeAws_queryAdditionalAttribute = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryAdditionalAttributes = (output, context) => {
+const de_AdditionalAttributes = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryAdditionalAttribute(entry, context);
+        return de_AdditionalAttribute(entry, context);
     });
 };
-const deserializeAws_queryAddTagsOutput = (output, context) => {
+const de_AddTagsOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryAppCookieStickinessPolicies = (output, context) => {
+const de_AppCookieStickinessPolicies = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryAppCookieStickinessPolicy(entry, context);
+        return de_AppCookieStickinessPolicy(entry, context);
     });
 };
-const deserializeAws_queryAppCookieStickinessPolicy = (output, context) => {
+const de_AppCookieStickinessPolicy = (output, context) => {
     const contents = {};
     if (output["PolicyName"] !== undefined) {
         contents.PolicyName = __expectString(output["PolicyName"]);
@@ -2578,34 +2578,34 @@ const deserializeAws_queryAppCookieStickinessPolicy = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryApplySecurityGroupsToLoadBalancerOutput = (output, context) => {
+const de_ApplySecurityGroupsToLoadBalancerOutput = (output, context) => {
     const contents = {};
     if (output.SecurityGroups === "") {
         contents.SecurityGroups = [];
     }
     else if (output["SecurityGroups"] !== undefined && output["SecurityGroups"]["member"] !== undefined) {
-        contents.SecurityGroups = deserializeAws_querySecurityGroups(__getArrayIfSingleItem(output["SecurityGroups"]["member"]), context);
+        contents.SecurityGroups = de_SecurityGroups(__getArrayIfSingleItem(output["SecurityGroups"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryAttachLoadBalancerToSubnetsOutput = (output, context) => {
+const de_AttachLoadBalancerToSubnetsOutput = (output, context) => {
     const contents = {};
     if (output.Subnets === "") {
         contents.Subnets = [];
     }
     else if (output["Subnets"] !== undefined && output["Subnets"]["member"] !== undefined) {
-        contents.Subnets = deserializeAws_querySubnets(__getArrayIfSingleItem(output["Subnets"]["member"]), context);
+        contents.Subnets = de_Subnets(__getArrayIfSingleItem(output["Subnets"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryAvailabilityZones = (output, context) => {
+const de_AvailabilityZones = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         return __expectString(entry);
     });
 };
-const deserializeAws_queryBackendServerDescription = (output, context) => {
+const de_BackendServerDescription = (output, context) => {
     const contents = {};
     if (output["InstancePort"] !== undefined) {
         contents.InstancePort = __strictParseInt32(output["InstancePort"]);
@@ -2614,32 +2614,32 @@ const deserializeAws_queryBackendServerDescription = (output, context) => {
         contents.PolicyNames = [];
     }
     else if (output["PolicyNames"] !== undefined && output["PolicyNames"]["member"] !== undefined) {
-        contents.PolicyNames = deserializeAws_queryPolicyNames(__getArrayIfSingleItem(output["PolicyNames"]["member"]), context);
+        contents.PolicyNames = de_PolicyNames(__getArrayIfSingleItem(output["PolicyNames"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryBackendServerDescriptions = (output, context) => {
+const de_BackendServerDescriptions = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryBackendServerDescription(entry, context);
+        return de_BackendServerDescription(entry, context);
     });
 };
-const deserializeAws_queryCertificateNotFoundException = (output, context) => {
+const de_CertificateNotFoundException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryConfigureHealthCheckOutput = (output, context) => {
+const de_ConfigureHealthCheckOutput = (output, context) => {
     const contents = {};
     if (output["HealthCheck"] !== undefined) {
-        contents.HealthCheck = deserializeAws_queryHealthCheck(output["HealthCheck"], context);
+        contents.HealthCheck = de_HealthCheck(output["HealthCheck"], context);
     }
     return contents;
 };
-const deserializeAws_queryConnectionDraining = (output, context) => {
+const de_ConnectionDraining = (output, context) => {
     const contents = {};
     if (output["Enabled"] !== undefined) {
         contents.Enabled = __parseBoolean(output["Enabled"]);
@@ -2649,186 +2649,186 @@ const deserializeAws_queryConnectionDraining = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryConnectionSettings = (output, context) => {
+const de_ConnectionSettings = (output, context) => {
     const contents = {};
     if (output["IdleTimeout"] !== undefined) {
         contents.IdleTimeout = __strictParseInt32(output["IdleTimeout"]);
     }
     return contents;
 };
-const deserializeAws_queryCreateAccessPointOutput = (output, context) => {
+const de_CreateAccessPointOutput = (output, context) => {
     const contents = {};
     if (output["DNSName"] !== undefined) {
         contents.DNSName = __expectString(output["DNSName"]);
     }
     return contents;
 };
-const deserializeAws_queryCreateAppCookieStickinessPolicyOutput = (output, context) => {
+const de_CreateAppCookieStickinessPolicyOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryCreateLBCookieStickinessPolicyOutput = (output, context) => {
+const de_CreateLBCookieStickinessPolicyOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryCreateLoadBalancerListenerOutput = (output, context) => {
+const de_CreateLoadBalancerListenerOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryCreateLoadBalancerPolicyOutput = (output, context) => {
+const de_CreateLoadBalancerPolicyOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryCrossZoneLoadBalancing = (output, context) => {
+const de_CrossZoneLoadBalancing = (output, context) => {
     const contents = {};
     if (output["Enabled"] !== undefined) {
         contents.Enabled = __parseBoolean(output["Enabled"]);
     }
     return contents;
 };
-const deserializeAws_queryDeleteAccessPointOutput = (output, context) => {
+const de_DeleteAccessPointOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryDeleteLoadBalancerListenerOutput = (output, context) => {
+const de_DeleteLoadBalancerListenerOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryDeleteLoadBalancerPolicyOutput = (output, context) => {
+const de_DeleteLoadBalancerPolicyOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_queryDependencyThrottleException = (output, context) => {
+const de_DependencyThrottleException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryDeregisterEndPointsOutput = (output, context) => {
+const de_DeregisterEndPointsOutput = (output, context) => {
     const contents = {};
     if (output.Instances === "") {
         contents.Instances = [];
     }
     else if (output["Instances"] !== undefined && output["Instances"]["member"] !== undefined) {
-        contents.Instances = deserializeAws_queryInstances(__getArrayIfSingleItem(output["Instances"]["member"]), context);
+        contents.Instances = de_Instances(__getArrayIfSingleItem(output["Instances"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDescribeAccessPointsOutput = (output, context) => {
+const de_DescribeAccessPointsOutput = (output, context) => {
     const contents = {};
     if (output.LoadBalancerDescriptions === "") {
         contents.LoadBalancerDescriptions = [];
     }
     else if (output["LoadBalancerDescriptions"] !== undefined &&
         output["LoadBalancerDescriptions"]["member"] !== undefined) {
-        contents.LoadBalancerDescriptions = deserializeAws_queryLoadBalancerDescriptions(__getArrayIfSingleItem(output["LoadBalancerDescriptions"]["member"]), context);
+        contents.LoadBalancerDescriptions = de_LoadBalancerDescriptions(__getArrayIfSingleItem(output["LoadBalancerDescriptions"]["member"]), context);
     }
     if (output["NextMarker"] !== undefined) {
         contents.NextMarker = __expectString(output["NextMarker"]);
     }
     return contents;
 };
-const deserializeAws_queryDescribeAccountLimitsOutput = (output, context) => {
+const de_DescribeAccountLimitsOutput = (output, context) => {
     const contents = {};
     if (output.Limits === "") {
         contents.Limits = [];
     }
     else if (output["Limits"] !== undefined && output["Limits"]["member"] !== undefined) {
-        contents.Limits = deserializeAws_queryLimits(__getArrayIfSingleItem(output["Limits"]["member"]), context);
+        contents.Limits = de_Limits(__getArrayIfSingleItem(output["Limits"]["member"]), context);
     }
     if (output["NextMarker"] !== undefined) {
         contents.NextMarker = __expectString(output["NextMarker"]);
     }
     return contents;
 };
-const deserializeAws_queryDescribeEndPointStateOutput = (output, context) => {
+const de_DescribeEndPointStateOutput = (output, context) => {
     const contents = {};
     if (output.InstanceStates === "") {
         contents.InstanceStates = [];
     }
     else if (output["InstanceStates"] !== undefined && output["InstanceStates"]["member"] !== undefined) {
-        contents.InstanceStates = deserializeAws_queryInstanceStates(__getArrayIfSingleItem(output["InstanceStates"]["member"]), context);
+        contents.InstanceStates = de_InstanceStates(__getArrayIfSingleItem(output["InstanceStates"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDescribeLoadBalancerAttributesOutput = (output, context) => {
+const de_DescribeLoadBalancerAttributesOutput = (output, context) => {
     const contents = {};
     if (output["LoadBalancerAttributes"] !== undefined) {
-        contents.LoadBalancerAttributes = deserializeAws_queryLoadBalancerAttributes(output["LoadBalancerAttributes"], context);
+        contents.LoadBalancerAttributes = de_LoadBalancerAttributes(output["LoadBalancerAttributes"], context);
     }
     return contents;
 };
-const deserializeAws_queryDescribeLoadBalancerPoliciesOutput = (output, context) => {
+const de_DescribeLoadBalancerPoliciesOutput = (output, context) => {
     const contents = {};
     if (output.PolicyDescriptions === "") {
         contents.PolicyDescriptions = [];
     }
     else if (output["PolicyDescriptions"] !== undefined && output["PolicyDescriptions"]["member"] !== undefined) {
-        contents.PolicyDescriptions = deserializeAws_queryPolicyDescriptions(__getArrayIfSingleItem(output["PolicyDescriptions"]["member"]), context);
+        contents.PolicyDescriptions = de_PolicyDescriptions(__getArrayIfSingleItem(output["PolicyDescriptions"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDescribeLoadBalancerPolicyTypesOutput = (output, context) => {
+const de_DescribeLoadBalancerPolicyTypesOutput = (output, context) => {
     const contents = {};
     if (output.PolicyTypeDescriptions === "") {
         contents.PolicyTypeDescriptions = [];
     }
     else if (output["PolicyTypeDescriptions"] !== undefined &&
         output["PolicyTypeDescriptions"]["member"] !== undefined) {
-        contents.PolicyTypeDescriptions = deserializeAws_queryPolicyTypeDescriptions(__getArrayIfSingleItem(output["PolicyTypeDescriptions"]["member"]), context);
+        contents.PolicyTypeDescriptions = de_PolicyTypeDescriptions(__getArrayIfSingleItem(output["PolicyTypeDescriptions"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDescribeTagsOutput = (output, context) => {
+const de_DescribeTagsOutput = (output, context) => {
     const contents = {};
     if (output.TagDescriptions === "") {
         contents.TagDescriptions = [];
     }
     else if (output["TagDescriptions"] !== undefined && output["TagDescriptions"]["member"] !== undefined) {
-        contents.TagDescriptions = deserializeAws_queryTagDescriptions(__getArrayIfSingleItem(output["TagDescriptions"]["member"]), context);
+        contents.TagDescriptions = de_TagDescriptions(__getArrayIfSingleItem(output["TagDescriptions"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDetachLoadBalancerFromSubnetsOutput = (output, context) => {
+const de_DetachLoadBalancerFromSubnetsOutput = (output, context) => {
     const contents = {};
     if (output.Subnets === "") {
         contents.Subnets = [];
     }
     else if (output["Subnets"] !== undefined && output["Subnets"]["member"] !== undefined) {
-        contents.Subnets = deserializeAws_querySubnets(__getArrayIfSingleItem(output["Subnets"]["member"]), context);
+        contents.Subnets = de_Subnets(__getArrayIfSingleItem(output["Subnets"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryDuplicateAccessPointNameException = (output, context) => {
+const de_DuplicateAccessPointNameException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryDuplicateListenerException = (output, context) => {
+const de_DuplicateListenerException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryDuplicatePolicyNameException = (output, context) => {
+const de_DuplicatePolicyNameException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryDuplicateTagKeysException = (output, context) => {
+const de_DuplicateTagKeysException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryHealthCheck = (output, context) => {
+const de_HealthCheck = (output, context) => {
     const contents = {};
     if (output["Target"] !== undefined) {
         contents.Target = __expectString(output["Target"]);
@@ -2847,21 +2847,21 @@ const deserializeAws_queryHealthCheck = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryInstance = (output, context) => {
+const de_Instance = (output, context) => {
     const contents = {};
     if (output["InstanceId"] !== undefined) {
         contents.InstanceId = __expectString(output["InstanceId"]);
     }
     return contents;
 };
-const deserializeAws_queryInstances = (output, context) => {
+const de_Instances = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryInstance(entry, context);
+        return de_Instance(entry, context);
     });
 };
-const deserializeAws_queryInstanceState = (output, context) => {
+const de_InstanceState = (output, context) => {
     const contents = {};
     if (output["InstanceId"] !== undefined) {
         contents.InstanceId = __expectString(output["InstanceId"]);
@@ -2877,56 +2877,56 @@ const deserializeAws_queryInstanceState = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryInstanceStates = (output, context) => {
+const de_InstanceStates = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryInstanceState(entry, context);
+        return de_InstanceState(entry, context);
     });
 };
-const deserializeAws_queryInvalidConfigurationRequestException = (output, context) => {
+const de_InvalidConfigurationRequestException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryInvalidEndPointException = (output, context) => {
+const de_InvalidEndPointException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryInvalidSchemeException = (output, context) => {
+const de_InvalidSchemeException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryInvalidSecurityGroupException = (output, context) => {
+const de_InvalidSecurityGroupException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryInvalidSubnetException = (output, context) => {
+const de_InvalidSubnetException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryLBCookieStickinessPolicies = (output, context) => {
+const de_LBCookieStickinessPolicies = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryLBCookieStickinessPolicy(entry, context);
+        return de_LBCookieStickinessPolicy(entry, context);
     });
 };
-const deserializeAws_queryLBCookieStickinessPolicy = (output, context) => {
+const de_LBCookieStickinessPolicy = (output, context) => {
     const contents = {};
     if (output["PolicyName"] !== undefined) {
         contents.PolicyName = __expectString(output["PolicyName"]);
@@ -2936,7 +2936,7 @@ const deserializeAws_queryLBCookieStickinessPolicy = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryLimit = (output, context) => {
+const de_Limit = (output, context) => {
     const contents = {};
     if (output["Name"] !== undefined) {
         contents.Name = __expectString(output["Name"]);
@@ -2946,14 +2946,14 @@ const deserializeAws_queryLimit = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryLimits = (output, context) => {
+const de_Limits = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryLimit(entry, context);
+        return de_Limit(entry, context);
     });
 };
-const deserializeAws_queryListener = (output, context) => {
+const de_Listener = (output, context) => {
     const contents = {};
     if (output["Protocol"] !== undefined) {
         contents.Protocol = __expectString(output["Protocol"]);
@@ -2972,63 +2972,63 @@ const deserializeAws_queryListener = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryListenerDescription = (output, context) => {
+const de_ListenerDescription = (output, context) => {
     const contents = {};
     if (output["Listener"] !== undefined) {
-        contents.Listener = deserializeAws_queryListener(output["Listener"], context);
+        contents.Listener = de_Listener(output["Listener"], context);
     }
     if (output.PolicyNames === "") {
         contents.PolicyNames = [];
     }
     else if (output["PolicyNames"] !== undefined && output["PolicyNames"]["member"] !== undefined) {
-        contents.PolicyNames = deserializeAws_queryPolicyNames(__getArrayIfSingleItem(output["PolicyNames"]["member"]), context);
+        contents.PolicyNames = de_PolicyNames(__getArrayIfSingleItem(output["PolicyNames"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryListenerDescriptions = (output, context) => {
+const de_ListenerDescriptions = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryListenerDescription(entry, context);
+        return de_ListenerDescription(entry, context);
     });
 };
-const deserializeAws_queryListenerNotFoundException = (output, context) => {
+const de_ListenerNotFoundException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryLoadBalancerAttributeNotFoundException = (output, context) => {
+const de_LoadBalancerAttributeNotFoundException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryLoadBalancerAttributes = (output, context) => {
+const de_LoadBalancerAttributes = (output, context) => {
     const contents = {};
     if (output["CrossZoneLoadBalancing"] !== undefined) {
-        contents.CrossZoneLoadBalancing = deserializeAws_queryCrossZoneLoadBalancing(output["CrossZoneLoadBalancing"], context);
+        contents.CrossZoneLoadBalancing = de_CrossZoneLoadBalancing(output["CrossZoneLoadBalancing"], context);
     }
     if (output["AccessLog"] !== undefined) {
-        contents.AccessLog = deserializeAws_queryAccessLog(output["AccessLog"], context);
+        contents.AccessLog = de_AccessLog(output["AccessLog"], context);
     }
     if (output["ConnectionDraining"] !== undefined) {
-        contents.ConnectionDraining = deserializeAws_queryConnectionDraining(output["ConnectionDraining"], context);
+        contents.ConnectionDraining = de_ConnectionDraining(output["ConnectionDraining"], context);
     }
     if (output["ConnectionSettings"] !== undefined) {
-        contents.ConnectionSettings = deserializeAws_queryConnectionSettings(output["ConnectionSettings"], context);
+        contents.ConnectionSettings = de_ConnectionSettings(output["ConnectionSettings"], context);
     }
     if (output.AdditionalAttributes === "") {
         contents.AdditionalAttributes = [];
     }
     else if (output["AdditionalAttributes"] !== undefined && output["AdditionalAttributes"]["member"] !== undefined) {
-        contents.AdditionalAttributes = deserializeAws_queryAdditionalAttributes(__getArrayIfSingleItem(output["AdditionalAttributes"]["member"]), context);
+        contents.AdditionalAttributes = de_AdditionalAttributes(__getArrayIfSingleItem(output["AdditionalAttributes"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryLoadBalancerDescription = (output, context) => {
+const de_LoadBalancerDescription = (output, context) => {
     const contents = {};
     if (output["LoadBalancerName"] !== undefined) {
         contents.LoadBalancerName = __expectString(output["LoadBalancerName"]);
@@ -3046,29 +3046,29 @@ const deserializeAws_queryLoadBalancerDescription = (output, context) => {
         contents.ListenerDescriptions = [];
     }
     else if (output["ListenerDescriptions"] !== undefined && output["ListenerDescriptions"]["member"] !== undefined) {
-        contents.ListenerDescriptions = deserializeAws_queryListenerDescriptions(__getArrayIfSingleItem(output["ListenerDescriptions"]["member"]), context);
+        contents.ListenerDescriptions = de_ListenerDescriptions(__getArrayIfSingleItem(output["ListenerDescriptions"]["member"]), context);
     }
     if (output["Policies"] !== undefined) {
-        contents.Policies = deserializeAws_queryPolicies(output["Policies"], context);
+        contents.Policies = de_Policies(output["Policies"], context);
     }
     if (output.BackendServerDescriptions === "") {
         contents.BackendServerDescriptions = [];
     }
     else if (output["BackendServerDescriptions"] !== undefined &&
         output["BackendServerDescriptions"]["member"] !== undefined) {
-        contents.BackendServerDescriptions = deserializeAws_queryBackendServerDescriptions(__getArrayIfSingleItem(output["BackendServerDescriptions"]["member"]), context);
+        contents.BackendServerDescriptions = de_BackendServerDescriptions(__getArrayIfSingleItem(output["BackendServerDescriptions"]["member"]), context);
     }
     if (output.AvailabilityZones === "") {
         contents.AvailabilityZones = [];
     }
     else if (output["AvailabilityZones"] !== undefined && output["AvailabilityZones"]["member"] !== undefined) {
-        contents.AvailabilityZones = deserializeAws_queryAvailabilityZones(__getArrayIfSingleItem(output["AvailabilityZones"]["member"]), context);
+        contents.AvailabilityZones = de_AvailabilityZones(__getArrayIfSingleItem(output["AvailabilityZones"]["member"]), context);
     }
     if (output.Subnets === "") {
         contents.Subnets = [];
     }
     else if (output["Subnets"] !== undefined && output["Subnets"]["member"] !== undefined) {
-        contents.Subnets = deserializeAws_querySubnets(__getArrayIfSingleItem(output["Subnets"]["member"]), context);
+        contents.Subnets = de_Subnets(__getArrayIfSingleItem(output["Subnets"]["member"]), context);
     }
     if (output["VPCId"] !== undefined) {
         contents.VPCId = __expectString(output["VPCId"]);
@@ -3077,19 +3077,19 @@ const deserializeAws_queryLoadBalancerDescription = (output, context) => {
         contents.Instances = [];
     }
     else if (output["Instances"] !== undefined && output["Instances"]["member"] !== undefined) {
-        contents.Instances = deserializeAws_queryInstances(__getArrayIfSingleItem(output["Instances"]["member"]), context);
+        contents.Instances = de_Instances(__getArrayIfSingleItem(output["Instances"]["member"]), context);
     }
     if (output["HealthCheck"] !== undefined) {
-        contents.HealthCheck = deserializeAws_queryHealthCheck(output["HealthCheck"], context);
+        contents.HealthCheck = de_HealthCheck(output["HealthCheck"], context);
     }
     if (output["SourceSecurityGroup"] !== undefined) {
-        contents.SourceSecurityGroup = deserializeAws_querySourceSecurityGroup(output["SourceSecurityGroup"], context);
+        contents.SourceSecurityGroup = de_SourceSecurityGroup(output["SourceSecurityGroup"], context);
     }
     if (output.SecurityGroups === "") {
         contents.SecurityGroups = [];
     }
     else if (output["SecurityGroups"] !== undefined && output["SecurityGroups"]["member"] !== undefined) {
-        contents.SecurityGroups = deserializeAws_querySecurityGroups(__getArrayIfSingleItem(output["SecurityGroups"]["member"]), context);
+        contents.SecurityGroups = de_SecurityGroups(__getArrayIfSingleItem(output["SecurityGroups"]["member"]), context);
     }
     if (output["CreatedTime"] !== undefined) {
         contents.CreatedTime = __expectNonNull(__parseRfc3339DateTimeWithOffset(output["CreatedTime"]));
@@ -3099,55 +3099,55 @@ const deserializeAws_queryLoadBalancerDescription = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryLoadBalancerDescriptions = (output, context) => {
+const de_LoadBalancerDescriptions = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryLoadBalancerDescription(entry, context);
+        return de_LoadBalancerDescription(entry, context);
     });
 };
-const deserializeAws_queryModifyLoadBalancerAttributesOutput = (output, context) => {
+const de_ModifyLoadBalancerAttributesOutput = (output, context) => {
     const contents = {};
     if (output["LoadBalancerName"] !== undefined) {
         contents.LoadBalancerName = __expectString(output["LoadBalancerName"]);
     }
     if (output["LoadBalancerAttributes"] !== undefined) {
-        contents.LoadBalancerAttributes = deserializeAws_queryLoadBalancerAttributes(output["LoadBalancerAttributes"], context);
+        contents.LoadBalancerAttributes = de_LoadBalancerAttributes(output["LoadBalancerAttributes"], context);
     }
     return contents;
 };
-const deserializeAws_queryOperationNotPermittedException = (output, context) => {
+const de_OperationNotPermittedException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryPolicies = (output, context) => {
+const de_Policies = (output, context) => {
     const contents = {};
     if (output.AppCookieStickinessPolicies === "") {
         contents.AppCookieStickinessPolicies = [];
     }
     else if (output["AppCookieStickinessPolicies"] !== undefined &&
         output["AppCookieStickinessPolicies"]["member"] !== undefined) {
-        contents.AppCookieStickinessPolicies = deserializeAws_queryAppCookieStickinessPolicies(__getArrayIfSingleItem(output["AppCookieStickinessPolicies"]["member"]), context);
+        contents.AppCookieStickinessPolicies = de_AppCookieStickinessPolicies(__getArrayIfSingleItem(output["AppCookieStickinessPolicies"]["member"]), context);
     }
     if (output.LBCookieStickinessPolicies === "") {
         contents.LBCookieStickinessPolicies = [];
     }
     else if (output["LBCookieStickinessPolicies"] !== undefined &&
         output["LBCookieStickinessPolicies"]["member"] !== undefined) {
-        contents.LBCookieStickinessPolicies = deserializeAws_queryLBCookieStickinessPolicies(__getArrayIfSingleItem(output["LBCookieStickinessPolicies"]["member"]), context);
+        contents.LBCookieStickinessPolicies = de_LBCookieStickinessPolicies(__getArrayIfSingleItem(output["LBCookieStickinessPolicies"]["member"]), context);
     }
     if (output.OtherPolicies === "") {
         contents.OtherPolicies = [];
     }
     else if (output["OtherPolicies"] !== undefined && output["OtherPolicies"]["member"] !== undefined) {
-        contents.OtherPolicies = deserializeAws_queryPolicyNames(__getArrayIfSingleItem(output["OtherPolicies"]["member"]), context);
+        contents.OtherPolicies = de_PolicyNames(__getArrayIfSingleItem(output["OtherPolicies"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryPolicyAttributeDescription = (output, context) => {
+const de_PolicyAttributeDescription = (output, context) => {
     const contents = {};
     if (output["AttributeName"] !== undefined) {
         contents.AttributeName = __expectString(output["AttributeName"]);
@@ -3157,14 +3157,14 @@ const deserializeAws_queryPolicyAttributeDescription = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryPolicyAttributeDescriptions = (output, context) => {
+const de_PolicyAttributeDescriptions = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryPolicyAttributeDescription(entry, context);
+        return de_PolicyAttributeDescription(entry, context);
     });
 };
-const deserializeAws_queryPolicyAttributeTypeDescription = (output, context) => {
+const de_PolicyAttributeTypeDescription = (output, context) => {
     const contents = {};
     if (output["AttributeName"] !== undefined) {
         contents.AttributeName = __expectString(output["AttributeName"]);
@@ -3183,14 +3183,14 @@ const deserializeAws_queryPolicyAttributeTypeDescription = (output, context) =>
     }
     return contents;
 };
-const deserializeAws_queryPolicyAttributeTypeDescriptions = (output, context) => {
+const de_PolicyAttributeTypeDescriptions = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryPolicyAttributeTypeDescription(entry, context);
+        return de_PolicyAttributeTypeDescription(entry, context);
     });
 };
-const deserializeAws_queryPolicyDescription = (output, context) => {
+const de_PolicyDescription = (output, context) => {
     const contents = {};
     if (output["PolicyName"] !== undefined) {
         contents.PolicyName = __expectString(output["PolicyName"]);
@@ -3203,32 +3203,32 @@ const deserializeAws_queryPolicyDescription = (output, context) => {
     }
     else if (output["PolicyAttributeDescriptions"] !== undefined &&
         output["PolicyAttributeDescriptions"]["member"] !== undefined) {
-        contents.PolicyAttributeDescriptions = deserializeAws_queryPolicyAttributeDescriptions(__getArrayIfSingleItem(output["PolicyAttributeDescriptions"]["member"]), context);
+        contents.PolicyAttributeDescriptions = de_PolicyAttributeDescriptions(__getArrayIfSingleItem(output["PolicyAttributeDescriptions"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryPolicyDescriptions = (output, context) => {
+const de_PolicyDescriptions = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryPolicyDescription(entry, context);
+        return de_PolicyDescription(entry, context);
     });
 };
-const deserializeAws_queryPolicyNames = (output, context) => {
+const de_PolicyNames = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         return __expectString(entry);
     });
 };
-const deserializeAws_queryPolicyNotFoundException = (output, context) => {
+const de_PolicyNotFoundException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryPolicyTypeDescription = (output, context) => {
+const de_PolicyTypeDescription = (output, context) => {
     const contents = {};
     if (output["PolicyTypeName"] !== undefined) {
         contents.PolicyTypeName = __expectString(output["PolicyTypeName"]);
@@ -3241,68 +3241,68 @@ const deserializeAws_queryPolicyTypeDescription = (output, context) => {
     }
     else if (output["PolicyAttributeTypeDescriptions"] !== undefined &&
         output["PolicyAttributeTypeDescriptions"]["member"] !== undefined) {
-        contents.PolicyAttributeTypeDescriptions = deserializeAws_queryPolicyAttributeTypeDescriptions(__getArrayIfSingleItem(output["PolicyAttributeTypeDescriptions"]["member"]), context);
+        contents.PolicyAttributeTypeDescriptions = de_PolicyAttributeTypeDescriptions(__getArrayIfSingleItem(output["PolicyAttributeTypeDescriptions"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryPolicyTypeDescriptions = (output, context) => {
+const de_PolicyTypeDescriptions = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryPolicyTypeDescription(entry, context);
+        return de_PolicyTypeDescription(entry, context);
     });
 };
-const deserializeAws_queryPolicyTypeNotFoundException = (output, context) => {
+const de_PolicyTypeNotFoundException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryRegisterEndPointsOutput = (output, context) => {
+const de_RegisterEndPointsOutput = (output, context) => {
     const contents = {};
     if (output.Instances === "") {
         contents.Instances = [];
     }
     else if (output["Instances"] !== undefined && output["Instances"]["member"] !== undefined) {
-        contents.Instances = deserializeAws_queryInstances(__getArrayIfSingleItem(output["Instances"]["member"]), context);
+        contents.Instances = de_Instances(__getArrayIfSingleItem(output["Instances"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryRemoveAvailabilityZonesOutput = (output, context) => {
+const de_RemoveAvailabilityZonesOutput = (output, context) => {
     const contents = {};
     if (output.AvailabilityZones === "") {
         contents.AvailabilityZones = [];
     }
     else if (output["AvailabilityZones"] !== undefined && output["AvailabilityZones"]["member"] !== undefined) {
-        contents.AvailabilityZones = deserializeAws_queryAvailabilityZones(__getArrayIfSingleItem(output["AvailabilityZones"]["member"]), context);
+        contents.AvailabilityZones = de_AvailabilityZones(__getArrayIfSingleItem(output["AvailabilityZones"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryRemoveTagsOutput = (output, context) => {
+const de_RemoveTagsOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_querySecurityGroups = (output, context) => {
+const de_SecurityGroups = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         return __expectString(entry);
     });
 };
-const deserializeAws_querySetLoadBalancerListenerSSLCertificateOutput = (output, context) => {
+const de_SetLoadBalancerListenerSSLCertificateOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_querySetLoadBalancerPoliciesForBackendServerOutput = (output, context) => {
+const de_SetLoadBalancerPoliciesForBackendServerOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_querySetLoadBalancerPoliciesOfListenerOutput = (output, context) => {
+const de_SetLoadBalancerPoliciesOfListenerOutput = (output, context) => {
     const contents = {};
     return contents;
 };
-const deserializeAws_querySourceSecurityGroup = (output, context) => {
+const de_SourceSecurityGroup = (output, context) => {
     const contents = {};
     if (output["OwnerAlias"] !== undefined) {
         contents.OwnerAlias = __expectString(output["OwnerAlias"]);
@@ -3312,21 +3312,21 @@ const deserializeAws_querySourceSecurityGroup = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_querySubnetNotFoundException = (output, context) => {
+const de_SubnetNotFoundException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_querySubnets = (output, context) => {
+const de_Subnets = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         return __expectString(entry);
     });
 };
-const deserializeAws_queryTag = (output, context) => {
+const de_Tag = (output, context) => {
     const contents = {};
     if (output["Key"] !== undefined) {
         contents.Key = __expectString(output["Key"]);
@@ -3336,7 +3336,7 @@ const deserializeAws_queryTag = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryTagDescription = (output, context) => {
+const de_TagDescription = (output, context) => {
     const contents = {};
     if (output["LoadBalancerName"] !== undefined) {
         contents.LoadBalancerName = __expectString(output["LoadBalancerName"]);
@@ -3345,46 +3345,46 @@ const deserializeAws_queryTagDescription = (output, context) => {
         contents.Tags = [];
     }
     else if (output["Tags"] !== undefined && output["Tags"]["member"] !== undefined) {
-        contents.Tags = deserializeAws_queryTagList(__getArrayIfSingleItem(output["Tags"]["member"]), context);
+        contents.Tags = de_TagList(__getArrayIfSingleItem(output["Tags"]["member"]), context);
     }
     return contents;
 };
-const deserializeAws_queryTagDescriptions = (output, context) => {
+const de_TagDescriptions = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryTagDescription(entry, context);
+        return de_TagDescription(entry, context);
     });
 };
-const deserializeAws_queryTagList = (output, context) => {
+const de_TagList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return deserializeAws_queryTag(entry, context);
+        return de_Tag(entry, context);
     });
 };
-const deserializeAws_queryTooManyAccessPointsException = (output, context) => {
+const de_TooManyAccessPointsException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryTooManyPoliciesException = (output, context) => {
+const de_TooManyPoliciesException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryTooManyTagsException = (output, context) => {
+const de_TooManyTagsException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryUnsupportedProtocolException = (output, context) => {
+const de_UnsupportedProtocolException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = __expectString(output["Message"]);