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

package/dist-cjs/protocols/Aws_query.js

@@ -1,404 +1,404 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deserializeAws_queryDetachLoadBalancerFromSubnetsCommand = exports.deserializeAws_queryDescribeTagsCommand = exports.deserializeAws_queryDescribeLoadBalancersCommand = exports.deserializeAws_queryDescribeLoadBalancerPolicyTypesCommand = exports.deserializeAws_queryDescribeLoadBalancerPoliciesCommand = exports.deserializeAws_queryDescribeLoadBalancerAttributesCommand = exports.deserializeAws_queryDescribeInstanceHealthCommand = exports.deserializeAws_queryDescribeAccountLimitsCommand = exports.deserializeAws_queryDeregisterInstancesFromLoadBalancerCommand = exports.deserializeAws_queryDeleteLoadBalancerPolicyCommand = exports.deserializeAws_queryDeleteLoadBalancerListenersCommand = exports.deserializeAws_queryDeleteLoadBalancerCommand = exports.deserializeAws_queryCreateLoadBalancerPolicyCommand = exports.deserializeAws_queryCreateLoadBalancerListenersCommand = exports.deserializeAws_queryCreateLoadBalancerCommand = exports.deserializeAws_queryCreateLBCookieStickinessPolicyCommand = exports.deserializeAws_queryCreateAppCookieStickinessPolicyCommand = exports.deserializeAws_queryConfigureHealthCheckCommand = exports.deserializeAws_queryAttachLoadBalancerToSubnetsCommand = exports.deserializeAws_queryApplySecurityGroupsToLoadBalancerCommand = exports.deserializeAws_queryAddTagsCommand = exports.serializeAws_querySetLoadBalancerPoliciesOfListenerCommand = exports.serializeAws_querySetLoadBalancerPoliciesForBackendServerCommand = exports.serializeAws_querySetLoadBalancerListenerSSLCertificateCommand = exports.serializeAws_queryRemoveTagsCommand = exports.serializeAws_queryRegisterInstancesWithLoadBalancerCommand = exports.serializeAws_queryModifyLoadBalancerAttributesCommand = exports.serializeAws_queryEnableAvailabilityZonesForLoadBalancerCommand = exports.serializeAws_queryDisableAvailabilityZonesForLoadBalancerCommand = exports.serializeAws_queryDetachLoadBalancerFromSubnetsCommand = exports.serializeAws_queryDescribeTagsCommand = exports.serializeAws_queryDescribeLoadBalancersCommand = exports.serializeAws_queryDescribeLoadBalancerPolicyTypesCommand = exports.serializeAws_queryDescribeLoadBalancerPoliciesCommand = exports.serializeAws_queryDescribeLoadBalancerAttributesCommand = exports.serializeAws_queryDescribeInstanceHealthCommand = exports.serializeAws_queryDescribeAccountLimitsCommand = exports.serializeAws_queryDeregisterInstancesFromLoadBalancerCommand = exports.serializeAws_queryDeleteLoadBalancerPolicyCommand = exports.serializeAws_queryDeleteLoadBalancerListenersCommand = exports.serializeAws_queryDeleteLoadBalancerCommand = exports.serializeAws_queryCreateLoadBalancerPolicyCommand = exports.serializeAws_queryCreateLoadBalancerListenersCommand = exports.serializeAws_queryCreateLoadBalancerCommand = exports.serializeAws_queryCreateLBCookieStickinessPolicyCommand = exports.serializeAws_queryCreateAppCookieStickinessPolicyCommand = exports.serializeAws_queryConfigureHealthCheckCommand = exports.serializeAws_queryAttachLoadBalancerToSubnetsCommand = exports.serializeAws_queryApplySecurityGroupsToLoadBalancerCommand = exports.serializeAws_queryAddTagsCommand = void 0;
-exports.deserializeAws_querySetLoadBalancerPoliciesOfListenerCommand = exports.deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommand = exports.deserializeAws_querySetLoadBalancerListenerSSLCertificateCommand = exports.deserializeAws_queryRemoveTagsCommand = exports.deserializeAws_queryRegisterInstancesWithLoadBalancerCommand = exports.deserializeAws_queryModifyLoadBalancerAttributesCommand = exports.deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommand = exports.deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommand = void 0;
+exports.de_DetachLoadBalancerFromSubnetsCommand = exports.de_DescribeTagsCommand = exports.de_DescribeLoadBalancersCommand = exports.de_DescribeLoadBalancerPolicyTypesCommand = exports.de_DescribeLoadBalancerPoliciesCommand = exports.de_DescribeLoadBalancerAttributesCommand = exports.de_DescribeInstanceHealthCommand = exports.de_DescribeAccountLimitsCommand = exports.de_DeregisterInstancesFromLoadBalancerCommand = exports.de_DeleteLoadBalancerPolicyCommand = exports.de_DeleteLoadBalancerListenersCommand = exports.de_DeleteLoadBalancerCommand = exports.de_CreateLoadBalancerPolicyCommand = exports.de_CreateLoadBalancerListenersCommand = exports.de_CreateLoadBalancerCommand = exports.de_CreateLBCookieStickinessPolicyCommand = exports.de_CreateAppCookieStickinessPolicyCommand = exports.de_ConfigureHealthCheckCommand = exports.de_AttachLoadBalancerToSubnetsCommand = exports.de_ApplySecurityGroupsToLoadBalancerCommand = exports.de_AddTagsCommand = exports.se_SetLoadBalancerPoliciesOfListenerCommand = exports.se_SetLoadBalancerPoliciesForBackendServerCommand = exports.se_SetLoadBalancerListenerSSLCertificateCommand = exports.se_RemoveTagsCommand = exports.se_RegisterInstancesWithLoadBalancerCommand = exports.se_ModifyLoadBalancerAttributesCommand = exports.se_EnableAvailabilityZonesForLoadBalancerCommand = exports.se_DisableAvailabilityZonesForLoadBalancerCommand = exports.se_DetachLoadBalancerFromSubnetsCommand = exports.se_DescribeTagsCommand = exports.se_DescribeLoadBalancersCommand = exports.se_DescribeLoadBalancerPolicyTypesCommand = exports.se_DescribeLoadBalancerPoliciesCommand = exports.se_DescribeLoadBalancerAttributesCommand = exports.se_DescribeInstanceHealthCommand = exports.se_DescribeAccountLimitsCommand = exports.se_DeregisterInstancesFromLoadBalancerCommand = exports.se_DeleteLoadBalancerPolicyCommand = exports.se_DeleteLoadBalancerListenersCommand = exports.se_DeleteLoadBalancerCommand = exports.se_CreateLoadBalancerPolicyCommand = exports.se_CreateLoadBalancerListenersCommand = exports.se_CreateLoadBalancerCommand = exports.se_CreateLBCookieStickinessPolicyCommand = exports.se_CreateAppCookieStickinessPolicyCommand = exports.se_ConfigureHealthCheckCommand = exports.se_AttachLoadBalancerToSubnetsCommand = exports.se_ApplySecurityGroupsToLoadBalancerCommand = exports.se_AddTagsCommand = void 0;
+exports.de_SetLoadBalancerPoliciesOfListenerCommand = exports.de_SetLoadBalancerPoliciesForBackendServerCommand = exports.de_SetLoadBalancerListenerSSLCertificateCommand = exports.de_RemoveTagsCommand = exports.de_RegisterInstancesWithLoadBalancerCommand = exports.de_ModifyLoadBalancerAttributesCommand = exports.de_EnableAvailabilityZonesForLoadBalancerCommand = exports.de_DisableAvailabilityZonesForLoadBalancerCommand = void 0;
 const protocol_http_1 = require("@aws-sdk/protocol-http");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const fast_xml_parser_1 = require("fast-xml-parser");
 const ElasticLoadBalancingServiceException_1 = require("../models/ElasticLoadBalancingServiceException");
 const models_0_1 = require("../models/models_0");
-const serializeAws_queryAddTagsCommand = async (input, context) => {
+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);
 };
-exports.serializeAws_queryAddTagsCommand = serializeAws_queryAddTagsCommand;
-const serializeAws_queryApplySecurityGroupsToLoadBalancerCommand = async (input, context) => {
+exports.se_AddTagsCommand = se_AddTagsCommand;
+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);
 };
-exports.serializeAws_queryApplySecurityGroupsToLoadBalancerCommand = serializeAws_queryApplySecurityGroupsToLoadBalancerCommand;
-const serializeAws_queryAttachLoadBalancerToSubnetsCommand = async (input, context) => {
+exports.se_ApplySecurityGroupsToLoadBalancerCommand = se_ApplySecurityGroupsToLoadBalancerCommand;
+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);
 };
-exports.serializeAws_queryAttachLoadBalancerToSubnetsCommand = serializeAws_queryAttachLoadBalancerToSubnetsCommand;
-const serializeAws_queryConfigureHealthCheckCommand = async (input, context) => {
+exports.se_AttachLoadBalancerToSubnetsCommand = se_AttachLoadBalancerToSubnetsCommand;
+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);
 };
-exports.serializeAws_queryConfigureHealthCheckCommand = serializeAws_queryConfigureHealthCheckCommand;
-const serializeAws_queryCreateAppCookieStickinessPolicyCommand = async (input, context) => {
+exports.se_ConfigureHealthCheckCommand = se_ConfigureHealthCheckCommand;
+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);
 };
-exports.serializeAws_queryCreateAppCookieStickinessPolicyCommand = serializeAws_queryCreateAppCookieStickinessPolicyCommand;
-const serializeAws_queryCreateLBCookieStickinessPolicyCommand = async (input, context) => {
+exports.se_CreateAppCookieStickinessPolicyCommand = se_CreateAppCookieStickinessPolicyCommand;
+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);
 };
-exports.serializeAws_queryCreateLBCookieStickinessPolicyCommand = serializeAws_queryCreateLBCookieStickinessPolicyCommand;
-const serializeAws_queryCreateLoadBalancerCommand = async (input, context) => {
+exports.se_CreateLBCookieStickinessPolicyCommand = se_CreateLBCookieStickinessPolicyCommand;
+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);
 };
-exports.serializeAws_queryCreateLoadBalancerCommand = serializeAws_queryCreateLoadBalancerCommand;
-const serializeAws_queryCreateLoadBalancerListenersCommand = async (input, context) => {
+exports.se_CreateLoadBalancerCommand = se_CreateLoadBalancerCommand;
+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);
 };
-exports.serializeAws_queryCreateLoadBalancerListenersCommand = serializeAws_queryCreateLoadBalancerListenersCommand;
-const serializeAws_queryCreateLoadBalancerPolicyCommand = async (input, context) => {
+exports.se_CreateLoadBalancerListenersCommand = se_CreateLoadBalancerListenersCommand;
+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);
 };
-exports.serializeAws_queryCreateLoadBalancerPolicyCommand = serializeAws_queryCreateLoadBalancerPolicyCommand;
-const serializeAws_queryDeleteLoadBalancerCommand = async (input, context) => {
+exports.se_CreateLoadBalancerPolicyCommand = se_CreateLoadBalancerPolicyCommand;
+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);
 };
-exports.serializeAws_queryDeleteLoadBalancerCommand = serializeAws_queryDeleteLoadBalancerCommand;
-const serializeAws_queryDeleteLoadBalancerListenersCommand = async (input, context) => {
+exports.se_DeleteLoadBalancerCommand = se_DeleteLoadBalancerCommand;
+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);
 };
-exports.serializeAws_queryDeleteLoadBalancerListenersCommand = serializeAws_queryDeleteLoadBalancerListenersCommand;
-const serializeAws_queryDeleteLoadBalancerPolicyCommand = async (input, context) => {
+exports.se_DeleteLoadBalancerListenersCommand = se_DeleteLoadBalancerListenersCommand;
+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);
 };
-exports.serializeAws_queryDeleteLoadBalancerPolicyCommand = serializeAws_queryDeleteLoadBalancerPolicyCommand;
-const serializeAws_queryDeregisterInstancesFromLoadBalancerCommand = async (input, context) => {
+exports.se_DeleteLoadBalancerPolicyCommand = se_DeleteLoadBalancerPolicyCommand;
+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);
 };
-exports.serializeAws_queryDeregisterInstancesFromLoadBalancerCommand = serializeAws_queryDeregisterInstancesFromLoadBalancerCommand;
-const serializeAws_queryDescribeAccountLimitsCommand = async (input, context) => {
+exports.se_DeregisterInstancesFromLoadBalancerCommand = se_DeregisterInstancesFromLoadBalancerCommand;
+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);
 };
-exports.serializeAws_queryDescribeAccountLimitsCommand = serializeAws_queryDescribeAccountLimitsCommand;
-const serializeAws_queryDescribeInstanceHealthCommand = async (input, context) => {
+exports.se_DescribeAccountLimitsCommand = se_DescribeAccountLimitsCommand;
+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);
 };
-exports.serializeAws_queryDescribeInstanceHealthCommand = serializeAws_queryDescribeInstanceHealthCommand;
-const serializeAws_queryDescribeLoadBalancerAttributesCommand = async (input, context) => {
+exports.se_DescribeInstanceHealthCommand = se_DescribeInstanceHealthCommand;
+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);
 };
-exports.serializeAws_queryDescribeLoadBalancerAttributesCommand = serializeAws_queryDescribeLoadBalancerAttributesCommand;
-const serializeAws_queryDescribeLoadBalancerPoliciesCommand = async (input, context) => {
+exports.se_DescribeLoadBalancerAttributesCommand = se_DescribeLoadBalancerAttributesCommand;
+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);
 };
-exports.serializeAws_queryDescribeLoadBalancerPoliciesCommand = serializeAws_queryDescribeLoadBalancerPoliciesCommand;
-const serializeAws_queryDescribeLoadBalancerPolicyTypesCommand = async (input, context) => {
+exports.se_DescribeLoadBalancerPoliciesCommand = se_DescribeLoadBalancerPoliciesCommand;
+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);
 };
-exports.serializeAws_queryDescribeLoadBalancerPolicyTypesCommand = serializeAws_queryDescribeLoadBalancerPolicyTypesCommand;
-const serializeAws_queryDescribeLoadBalancersCommand = async (input, context) => {
+exports.se_DescribeLoadBalancerPolicyTypesCommand = se_DescribeLoadBalancerPolicyTypesCommand;
+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);
 };
-exports.serializeAws_queryDescribeLoadBalancersCommand = serializeAws_queryDescribeLoadBalancersCommand;
-const serializeAws_queryDescribeTagsCommand = async (input, context) => {
+exports.se_DescribeLoadBalancersCommand = se_DescribeLoadBalancersCommand;
+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);
 };
-exports.serializeAws_queryDescribeTagsCommand = serializeAws_queryDescribeTagsCommand;
-const serializeAws_queryDetachLoadBalancerFromSubnetsCommand = async (input, context) => {
+exports.se_DescribeTagsCommand = se_DescribeTagsCommand;
+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);
 };
-exports.serializeAws_queryDetachLoadBalancerFromSubnetsCommand = serializeAws_queryDetachLoadBalancerFromSubnetsCommand;
-const serializeAws_queryDisableAvailabilityZonesForLoadBalancerCommand = async (input, context) => {
+exports.se_DetachLoadBalancerFromSubnetsCommand = se_DetachLoadBalancerFromSubnetsCommand;
+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);
 };
-exports.serializeAws_queryDisableAvailabilityZonesForLoadBalancerCommand = serializeAws_queryDisableAvailabilityZonesForLoadBalancerCommand;
-const serializeAws_queryEnableAvailabilityZonesForLoadBalancerCommand = async (input, context) => {
+exports.se_DisableAvailabilityZonesForLoadBalancerCommand = se_DisableAvailabilityZonesForLoadBalancerCommand;
+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);
 };
-exports.serializeAws_queryEnableAvailabilityZonesForLoadBalancerCommand = serializeAws_queryEnableAvailabilityZonesForLoadBalancerCommand;
-const serializeAws_queryModifyLoadBalancerAttributesCommand = async (input, context) => {
+exports.se_EnableAvailabilityZonesForLoadBalancerCommand = se_EnableAvailabilityZonesForLoadBalancerCommand;
+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);
 };
-exports.serializeAws_queryModifyLoadBalancerAttributesCommand = serializeAws_queryModifyLoadBalancerAttributesCommand;
-const serializeAws_queryRegisterInstancesWithLoadBalancerCommand = async (input, context) => {
+exports.se_ModifyLoadBalancerAttributesCommand = se_ModifyLoadBalancerAttributesCommand;
+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);
 };
-exports.serializeAws_queryRegisterInstancesWithLoadBalancerCommand = serializeAws_queryRegisterInstancesWithLoadBalancerCommand;
-const serializeAws_queryRemoveTagsCommand = async (input, context) => {
+exports.se_RegisterInstancesWithLoadBalancerCommand = se_RegisterInstancesWithLoadBalancerCommand;
+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);
 };
-exports.serializeAws_queryRemoveTagsCommand = serializeAws_queryRemoveTagsCommand;
-const serializeAws_querySetLoadBalancerListenerSSLCertificateCommand = async (input, context) => {
+exports.se_RemoveTagsCommand = se_RemoveTagsCommand;
+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);
 };
-exports.serializeAws_querySetLoadBalancerListenerSSLCertificateCommand = serializeAws_querySetLoadBalancerListenerSSLCertificateCommand;
-const serializeAws_querySetLoadBalancerPoliciesForBackendServerCommand = async (input, context) => {
+exports.se_SetLoadBalancerListenerSSLCertificateCommand = se_SetLoadBalancerListenerSSLCertificateCommand;
+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);
 };
-exports.serializeAws_querySetLoadBalancerPoliciesForBackendServerCommand = serializeAws_querySetLoadBalancerPoliciesForBackendServerCommand;
-const serializeAws_querySetLoadBalancerPoliciesOfListenerCommand = async (input, context) => {
+exports.se_SetLoadBalancerPoliciesForBackendServerCommand = se_SetLoadBalancerPoliciesForBackendServerCommand;
+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);
 };
-exports.serializeAws_querySetLoadBalancerPoliciesOfListenerCommand = serializeAws_querySetLoadBalancerPoliciesOfListenerCommand;
-const deserializeAws_queryAddTagsCommand = async (output, context) => {
+exports.se_SetLoadBalancerPoliciesOfListenerCommand = se_SetLoadBalancerPoliciesOfListenerCommand;
+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);
 };
-exports.deserializeAws_queryAddTagsCommand = deserializeAws_queryAddTagsCommand;
-const deserializeAws_queryAddTagsCommandError = async (output, context) => {
+exports.de_AddTagsCommand = de_AddTagsCommand;
+const de_AddTagsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -407,13 +407,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -424,21 +424,21 @@ const deserializeAws_queryAddTagsCommandError = async (output, context) => {
             });
     }
 };
-const deserializeAws_queryApplySecurityGroupsToLoadBalancerCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryApplySecurityGroupsToLoadBalancerCommand = deserializeAws_queryApplySecurityGroupsToLoadBalancerCommand;
-const deserializeAws_queryApplySecurityGroupsToLoadBalancerCommandError = async (output, context) => {
+exports.de_ApplySecurityGroupsToLoadBalancerCommand = de_ApplySecurityGroupsToLoadBalancerCommand;
+const de_ApplySecurityGroupsToLoadBalancerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -447,13 +447,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -464,21 +464,21 @@ const deserializeAws_queryApplySecurityGroupsToLoadBalancerCommandError = async
             });
     }
 };
-const deserializeAws_queryAttachLoadBalancerToSubnetsCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryAttachLoadBalancerToSubnetsCommand = deserializeAws_queryAttachLoadBalancerToSubnetsCommand;
-const deserializeAws_queryAttachLoadBalancerToSubnetsCommandError = async (output, context) => {
+exports.de_AttachLoadBalancerToSubnetsCommand = de_AttachLoadBalancerToSubnetsCommand;
+const de_AttachLoadBalancerToSubnetsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -487,16 +487,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -507,21 +507,21 @@ const deserializeAws_queryAttachLoadBalancerToSubnetsCommandError = async (outpu
             });
     }
 };
-const deserializeAws_queryConfigureHealthCheckCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryConfigureHealthCheckCommand = deserializeAws_queryConfigureHealthCheckCommand;
-const deserializeAws_queryConfigureHealthCheckCommandError = async (output, context) => {
+exports.de_ConfigureHealthCheckCommand = de_ConfigureHealthCheckCommand;
+const de_ConfigureHealthCheckCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -530,7 +530,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -541,21 +541,21 @@ const deserializeAws_queryConfigureHealthCheckCommandError = async (output, cont
             });
     }
 };
-const deserializeAws_queryCreateAppCookieStickinessPolicyCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryCreateAppCookieStickinessPolicyCommand = deserializeAws_queryCreateAppCookieStickinessPolicyCommand;
-const deserializeAws_queryCreateAppCookieStickinessPolicyCommandError = async (output, context) => {
+exports.de_CreateAppCookieStickinessPolicyCommand = de_CreateAppCookieStickinessPolicyCommand;
+const de_CreateAppCookieStickinessPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -564,16 +564,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -584,21 +584,21 @@ const deserializeAws_queryCreateAppCookieStickinessPolicyCommandError = async (o
             });
     }
 };
-const deserializeAws_queryCreateLBCookieStickinessPolicyCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryCreateLBCookieStickinessPolicyCommand = deserializeAws_queryCreateLBCookieStickinessPolicyCommand;
-const deserializeAws_queryCreateLBCookieStickinessPolicyCommandError = async (output, context) => {
+exports.de_CreateLBCookieStickinessPolicyCommand = de_CreateLBCookieStickinessPolicyCommand;
+const de_CreateLBCookieStickinessPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -607,16 +607,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -627,21 +627,21 @@ const deserializeAws_queryCreateLBCookieStickinessPolicyCommandError = async (ou
             });
     }
 };
-const deserializeAws_queryCreateLoadBalancerCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryCreateLoadBalancerCommand = deserializeAws_queryCreateLoadBalancerCommand;
-const deserializeAws_queryCreateLoadBalancerCommandError = async (output, context) => {
+exports.de_CreateLoadBalancerCommand = de_CreateLoadBalancerCommand;
+const de_CreateLoadBalancerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -650,40 +650,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -694,21 +694,21 @@ const deserializeAws_queryCreateLoadBalancerCommandError = async (output, contex
             });
     }
 };
-const deserializeAws_queryCreateLoadBalancerListenersCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryCreateLoadBalancerListenersCommand = deserializeAws_queryCreateLoadBalancerListenersCommand;
-const deserializeAws_queryCreateLoadBalancerListenersCommandError = async (output, context) => {
+exports.de_CreateLoadBalancerListenersCommand = de_CreateLoadBalancerListenersCommand;
+const de_CreateLoadBalancerListenersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -717,19 +717,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -740,21 +740,21 @@ const deserializeAws_queryCreateLoadBalancerListenersCommandError = async (outpu
             });
     }
 };
-const deserializeAws_queryCreateLoadBalancerPolicyCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryCreateLoadBalancerPolicyCommand = deserializeAws_queryCreateLoadBalancerPolicyCommand;
-const deserializeAws_queryCreateLoadBalancerPolicyCommandError = async (output, context) => {
+exports.de_CreateLoadBalancerPolicyCommand = de_CreateLoadBalancerPolicyCommand;
+const de_CreateLoadBalancerPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -763,19 +763,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -786,21 +786,21 @@ const deserializeAws_queryCreateLoadBalancerPolicyCommandError = async (output,
             });
     }
 };
-const deserializeAws_queryDeleteLoadBalancerCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryDeleteLoadBalancerCommand = deserializeAws_queryDeleteLoadBalancerCommand;
-const deserializeAws_queryDeleteLoadBalancerCommandError = async (output, context) => {
+exports.de_DeleteLoadBalancerCommand = de_DeleteLoadBalancerCommand;
+const de_DeleteLoadBalancerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -814,21 +814,21 @@ const deserializeAws_queryDeleteLoadBalancerCommandError = async (output, contex
         errorCode,
     });
 };
-const deserializeAws_queryDeleteLoadBalancerListenersCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryDeleteLoadBalancerListenersCommand = deserializeAws_queryDeleteLoadBalancerListenersCommand;
-const deserializeAws_queryDeleteLoadBalancerListenersCommandError = async (output, context) => {
+exports.de_DeleteLoadBalancerListenersCommand = de_DeleteLoadBalancerListenersCommand;
+const de_DeleteLoadBalancerListenersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -837,7 +837,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -848,21 +848,21 @@ const deserializeAws_queryDeleteLoadBalancerListenersCommandError = async (outpu
             });
     }
 };
-const deserializeAws_queryDeleteLoadBalancerPolicyCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryDeleteLoadBalancerPolicyCommand = deserializeAws_queryDeleteLoadBalancerPolicyCommand;
-const deserializeAws_queryDeleteLoadBalancerPolicyCommandError = async (output, context) => {
+exports.de_DeleteLoadBalancerPolicyCommand = de_DeleteLoadBalancerPolicyCommand;
+const de_DeleteLoadBalancerPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -871,10 +871,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -885,21 +885,21 @@ const deserializeAws_queryDeleteLoadBalancerPolicyCommandError = async (output,
             });
     }
 };
-const deserializeAws_queryDeregisterInstancesFromLoadBalancerCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryDeregisterInstancesFromLoadBalancerCommand = deserializeAws_queryDeregisterInstancesFromLoadBalancerCommand;
-const deserializeAws_queryDeregisterInstancesFromLoadBalancerCommandError = async (output, context) => {
+exports.de_DeregisterInstancesFromLoadBalancerCommand = de_DeregisterInstancesFromLoadBalancerCommand;
+const de_DeregisterInstancesFromLoadBalancerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -908,10 +908,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -922,21 +922,21 @@ const deserializeAws_queryDeregisterInstancesFromLoadBalancerCommandError = asyn
             });
     }
 };
-const deserializeAws_queryDescribeAccountLimitsCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryDescribeAccountLimitsCommand = deserializeAws_queryDescribeAccountLimitsCommand;
-const deserializeAws_queryDescribeAccountLimitsCommandError = async (output, context) => {
+exports.de_DescribeAccountLimitsCommand = de_DescribeAccountLimitsCommand;
+const de_DescribeAccountLimitsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -950,21 +950,21 @@ const deserializeAws_queryDescribeAccountLimitsCommandError = async (output, con
         errorCode,
     });
 };
-const deserializeAws_queryDescribeInstanceHealthCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryDescribeInstanceHealthCommand = deserializeAws_queryDescribeInstanceHealthCommand;
-const deserializeAws_queryDescribeInstanceHealthCommandError = async (output, context) => {
+exports.de_DescribeInstanceHealthCommand = de_DescribeInstanceHealthCommand;
+const de_DescribeInstanceHealthCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -973,10 +973,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -987,21 +987,21 @@ const deserializeAws_queryDescribeInstanceHealthCommandError = async (output, co
             });
     }
 };
-const deserializeAws_queryDescribeLoadBalancerAttributesCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryDescribeLoadBalancerAttributesCommand = deserializeAws_queryDescribeLoadBalancerAttributesCommand;
-const deserializeAws_queryDescribeLoadBalancerAttributesCommandError = async (output, context) => {
+exports.de_DescribeLoadBalancerAttributesCommand = de_DescribeLoadBalancerAttributesCommand;
+const de_DescribeLoadBalancerAttributesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1010,10 +1010,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1024,21 +1024,21 @@ const deserializeAws_queryDescribeLoadBalancerAttributesCommandError = async (ou
             });
     }
 };
-const deserializeAws_queryDescribeLoadBalancerPoliciesCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryDescribeLoadBalancerPoliciesCommand = deserializeAws_queryDescribeLoadBalancerPoliciesCommand;
-const deserializeAws_queryDescribeLoadBalancerPoliciesCommandError = async (output, context) => {
+exports.de_DescribeLoadBalancerPoliciesCommand = de_DescribeLoadBalancerPoliciesCommand;
+const de_DescribeLoadBalancerPoliciesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1047,10 +1047,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1061,21 +1061,21 @@ const deserializeAws_queryDescribeLoadBalancerPoliciesCommandError = async (outp
             });
     }
 };
-const deserializeAws_queryDescribeLoadBalancerPolicyTypesCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryDescribeLoadBalancerPolicyTypesCommand = deserializeAws_queryDescribeLoadBalancerPolicyTypesCommand;
-const deserializeAws_queryDescribeLoadBalancerPolicyTypesCommandError = async (output, context) => {
+exports.de_DescribeLoadBalancerPolicyTypesCommand = de_DescribeLoadBalancerPolicyTypesCommand;
+const de_DescribeLoadBalancerPolicyTypesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1084,7 +1084,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1095,21 +1095,21 @@ const deserializeAws_queryDescribeLoadBalancerPolicyTypesCommandError = async (o
             });
     }
 };
-const deserializeAws_queryDescribeLoadBalancersCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryDescribeLoadBalancersCommand = deserializeAws_queryDescribeLoadBalancersCommand;
-const deserializeAws_queryDescribeLoadBalancersCommandError = async (output, context) => {
+exports.de_DescribeLoadBalancersCommand = de_DescribeLoadBalancersCommand;
+const de_DescribeLoadBalancersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1118,10 +1118,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1132,21 +1132,21 @@ const deserializeAws_queryDescribeLoadBalancersCommandError = async (output, con
             });
     }
 };
-const deserializeAws_queryDescribeTagsCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryDescribeTagsCommand = deserializeAws_queryDescribeTagsCommand;
-const deserializeAws_queryDescribeTagsCommandError = async (output, context) => {
+exports.de_DescribeTagsCommand = de_DescribeTagsCommand;
+const de_DescribeTagsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1155,7 +1155,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1166,21 +1166,21 @@ const deserializeAws_queryDescribeTagsCommandError = async (output, context) =>
             });
     }
 };
-const deserializeAws_queryDetachLoadBalancerFromSubnetsCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryDetachLoadBalancerFromSubnetsCommand = deserializeAws_queryDetachLoadBalancerFromSubnetsCommand;
-const deserializeAws_queryDetachLoadBalancerFromSubnetsCommandError = async (output, context) => {
+exports.de_DetachLoadBalancerFromSubnetsCommand = de_DetachLoadBalancerFromSubnetsCommand;
+const de_DetachLoadBalancerFromSubnetsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1189,10 +1189,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1203,21 +1203,21 @@ const deserializeAws_queryDetachLoadBalancerFromSubnetsCommandError = async (out
             });
     }
 };
-const deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommand = deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommand;
-const deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommandError = async (output, context) => {
+exports.de_DisableAvailabilityZonesForLoadBalancerCommand = de_DisableAvailabilityZonesForLoadBalancerCommand;
+const de_DisableAvailabilityZonesForLoadBalancerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1226,10 +1226,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1240,21 +1240,21 @@ const deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommandError =
             });
     }
 };
-const deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommand = deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommand;
-const deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommandError = async (output, context) => {
+exports.de_EnableAvailabilityZonesForLoadBalancerCommand = de_EnableAvailabilityZonesForLoadBalancerCommand;
+const de_EnableAvailabilityZonesForLoadBalancerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1263,7 +1263,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1274,21 +1274,21 @@ const deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommandError = a
             });
     }
 };
-const deserializeAws_queryModifyLoadBalancerAttributesCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryModifyLoadBalancerAttributesCommand = deserializeAws_queryModifyLoadBalancerAttributesCommand;
-const deserializeAws_queryModifyLoadBalancerAttributesCommandError = async (output, context) => {
+exports.de_ModifyLoadBalancerAttributesCommand = de_ModifyLoadBalancerAttributesCommand;
+const de_ModifyLoadBalancerAttributesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1297,13 +1297,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1314,21 +1314,21 @@ const deserializeAws_queryModifyLoadBalancerAttributesCommandError = async (outp
             });
     }
 };
-const deserializeAws_queryRegisterInstancesWithLoadBalancerCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryRegisterInstancesWithLoadBalancerCommand = deserializeAws_queryRegisterInstancesWithLoadBalancerCommand;
-const deserializeAws_queryRegisterInstancesWithLoadBalancerCommandError = async (output, context) => {
+exports.de_RegisterInstancesWithLoadBalancerCommand = de_RegisterInstancesWithLoadBalancerCommand;
+const de_RegisterInstancesWithLoadBalancerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1337,10 +1337,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1351,21 +1351,21 @@ const deserializeAws_queryRegisterInstancesWithLoadBalancerCommandError = async
             });
     }
 };
-const deserializeAws_queryRemoveTagsCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_queryRemoveTagsCommand = deserializeAws_queryRemoveTagsCommand;
-const deserializeAws_queryRemoveTagsCommandError = async (output, context) => {
+exports.de_RemoveTagsCommand = de_RemoveTagsCommand;
+const de_RemoveTagsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1374,7 +1374,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1385,21 +1385,21 @@ const deserializeAws_queryRemoveTagsCommandError = async (output, context) => {
             });
     }
 };
-const deserializeAws_querySetLoadBalancerListenerSSLCertificateCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_querySetLoadBalancerListenerSSLCertificateCommand = deserializeAws_querySetLoadBalancerListenerSSLCertificateCommand;
-const deserializeAws_querySetLoadBalancerListenerSSLCertificateCommandError = async (output, context) => {
+exports.de_SetLoadBalancerListenerSSLCertificateCommand = de_SetLoadBalancerListenerSSLCertificateCommand;
+const de_SetLoadBalancerListenerSSLCertificateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1408,19 +1408,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1431,21 +1431,21 @@ const deserializeAws_querySetLoadBalancerListenerSSLCertificateCommandError = as
             });
     }
 };
-const deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommand = deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommand;
-const deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommandError = async (output, context) => {
+exports.de_SetLoadBalancerPoliciesForBackendServerCommand = de_SetLoadBalancerPoliciesForBackendServerCommand;
+const de_SetLoadBalancerPoliciesForBackendServerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1454,13 +1454,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1471,21 +1471,21 @@ const deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommandError =
             });
     }
 };
-const deserializeAws_querySetLoadBalancerPoliciesOfListenerCommand = async (output, context) => {
+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);
 };
-exports.deserializeAws_querySetLoadBalancerPoliciesOfListenerCommand = deserializeAws_querySetLoadBalancerPoliciesOfListenerCommand;
-const deserializeAws_querySetLoadBalancerPoliciesOfListenerCommandError = async (output, context) => {
+exports.de_SetLoadBalancerPoliciesOfListenerCommand = de_SetLoadBalancerPoliciesOfListenerCommand;
+const de_SetLoadBalancerPoliciesOfListenerCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1494,16 +1494,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1514,205 +1514,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 models_0_1.AccessPointNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.CertificateNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.DependencyThrottleException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.DuplicateAccessPointNameException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.DuplicateListenerException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.DuplicatePolicyNameException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.DuplicateTagKeysException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.InvalidConfigurationRequestException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.InvalidEndPointException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.InvalidSchemeException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.InvalidSecurityGroupException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.InvalidSubnetException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.ListenerNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.LoadBalancerAttributeNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.OperationNotPermittedException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.PolicyNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.PolicyTypeNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.SubnetNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.TooManyAccessPointsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.TooManyPoliciesException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.TooManyTagsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.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 models_0_1.UnsupportedProtocolException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
-const serializeAws_queryAccessLog = (input, context) => {
+const se_AccessLog = (input, context) => {
     const entries = {};
     if (input.Enabled != null) {
         entries["Enabled"] = input.Enabled;
@@ -1728,13 +1728,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 = [];
         }
@@ -1745,7 +1745,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;
@@ -1755,14 +1755,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;
         });
@@ -1770,10 +1770,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 = [];
         }
@@ -1783,7 +1783,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 = [];
         }
@@ -1794,13 +1794,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 = [];
         }
@@ -1811,13 +1811,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 = [];
         }
@@ -1828,7 +1828,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) {
@@ -1840,13 +1840,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;
@@ -1854,7 +1854,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;
@@ -1864,20 +1864,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 = [];
         }
@@ -1887,7 +1887,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 = [];
         }
@@ -1897,7 +1897,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 = [];
         }
@@ -1907,7 +1907,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 = [];
         }
@@ -1920,7 +1920,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 = [];
         }
@@ -1931,7 +1931,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;
@@ -1944,7 +1944,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;
@@ -1957,13 +1957,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 = [];
         }
@@ -1974,7 +1974,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;
@@ -1986,7 +1986,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 = [];
         }
@@ -1997,27 +1997,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 = [];
         }
@@ -2028,7 +2028,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;
@@ -2038,13 +2038,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 = [];
         }
@@ -2055,10 +2055,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 = [];
         }
@@ -2075,7 +2075,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;
@@ -2085,13 +2085,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 = [];
         }
@@ -2102,20 +2102,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 = [];
         }
@@ -2126,10 +2126,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 = [];
         }
@@ -2140,10 +2140,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 = [];
         }
@@ -2154,13 +2154,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 = [];
         }
@@ -2171,7 +2171,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;
@@ -2190,21 +2190,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;
         });
@@ -2212,7 +2212,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;
@@ -2231,14 +2231,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;
         });
@@ -2246,38 +2246,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 = [];
         }
@@ -2288,7 +2288,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) {
@@ -2300,7 +2300,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) {
@@ -2312,13 +2312,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;
@@ -2326,7 +2326,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;
@@ -2336,14 +2336,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;
         });
@@ -2351,7 +2351,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) {
@@ -2363,7 +2363,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) {
@@ -2375,7 +2375,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) {
@@ -2387,13 +2387,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 = [];
         }
@@ -2404,13 +2404,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 = [];
         }
@@ -2421,10 +2421,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 = [];
         }
@@ -2434,7 +2434,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 = [];
         }
@@ -2445,7 +2445,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) {
@@ -2457,7 +2457,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;
@@ -2470,7 +2470,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;
@@ -2479,7 +2479,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 = [];
         }
@@ -2490,7 +2490,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;
@@ -2499,7 +2499,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 = [];
         }
@@ -2510,7 +2510,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) {
@@ -2522,7 +2522,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;
@@ -2532,14 +2532,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;
         });
@@ -2547,21 +2547,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;
         });
@@ -2569,7 +2569,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 = (0, smithy_client_1.parseBoolean)(output["Enabled"]);
@@ -2585,24 +2585,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 = (0, smithy_client_1.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((0, smithy_client_1.getArrayIfSingleItem)(output["AvailabilityZones"]["member"]), context);
+        contents.AvailabilityZones = de_AvailabilityZones((0, smithy_client_1.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 = (0, smithy_client_1.expectString)(output["Key"]);
@@ -2612,25 +2612,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 = (0, smithy_client_1.expectString)(output["PolicyName"]);
@@ -2640,34 +2640,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((0, smithy_client_1.getArrayIfSingleItem)(output["SecurityGroups"]["member"]), context);
+        contents.SecurityGroups = de_SecurityGroups((0, smithy_client_1.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((0, smithy_client_1.getArrayIfSingleItem)(output["Subnets"]["member"]), context);
+        contents.Subnets = de_Subnets((0, smithy_client_1.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 (0, smithy_client_1.expectString)(entry);
     });
 };
-const deserializeAws_queryBackendServerDescription = (output, context) => {
+const de_BackendServerDescription = (output, context) => {
     const contents = {};
     if (output["InstancePort"] !== undefined) {
         contents.InstancePort = (0, smithy_client_1.strictParseInt32)(output["InstancePort"]);
@@ -2676,32 +2676,32 @@ const deserializeAws_queryBackendServerDescription = (output, context) => {
         contents.PolicyNames = [];
     }
     else if (output["PolicyNames"] !== undefined && output["PolicyNames"]["member"] !== undefined) {
-        contents.PolicyNames = deserializeAws_queryPolicyNames((0, smithy_client_1.getArrayIfSingleItem)(output["PolicyNames"]["member"]), context);
+        contents.PolicyNames = de_PolicyNames((0, smithy_client_1.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 = (0, smithy_client_1.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 = (0, smithy_client_1.parseBoolean)(output["Enabled"]);
@@ -2711,186 +2711,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 = (0, smithy_client_1.strictParseInt32)(output["IdleTimeout"]);
     }
     return contents;
 };
-const deserializeAws_queryCreateAccessPointOutput = (output, context) => {
+const de_CreateAccessPointOutput = (output, context) => {
     const contents = {};
     if (output["DNSName"] !== undefined) {
         contents.DNSName = (0, smithy_client_1.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 = (0, smithy_client_1.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 = (0, smithy_client_1.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((0, smithy_client_1.getArrayIfSingleItem)(output["Instances"]["member"]), context);
+        contents.Instances = de_Instances((0, smithy_client_1.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((0, smithy_client_1.getArrayIfSingleItem)(output["LoadBalancerDescriptions"]["member"]), context);
+        contents.LoadBalancerDescriptions = de_LoadBalancerDescriptions((0, smithy_client_1.getArrayIfSingleItem)(output["LoadBalancerDescriptions"]["member"]), context);
     }
     if (output["NextMarker"] !== undefined) {
         contents.NextMarker = (0, smithy_client_1.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((0, smithy_client_1.getArrayIfSingleItem)(output["Limits"]["member"]), context);
+        contents.Limits = de_Limits((0, smithy_client_1.getArrayIfSingleItem)(output["Limits"]["member"]), context);
     }
     if (output["NextMarker"] !== undefined) {
         contents.NextMarker = (0, smithy_client_1.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((0, smithy_client_1.getArrayIfSingleItem)(output["InstanceStates"]["member"]), context);
+        contents.InstanceStates = de_InstanceStates((0, smithy_client_1.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((0, smithy_client_1.getArrayIfSingleItem)(output["PolicyDescriptions"]["member"]), context);
+        contents.PolicyDescriptions = de_PolicyDescriptions((0, smithy_client_1.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((0, smithy_client_1.getArrayIfSingleItem)(output["PolicyTypeDescriptions"]["member"]), context);
+        contents.PolicyTypeDescriptions = de_PolicyTypeDescriptions((0, smithy_client_1.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((0, smithy_client_1.getArrayIfSingleItem)(output["TagDescriptions"]["member"]), context);
+        contents.TagDescriptions = de_TagDescriptions((0, smithy_client_1.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((0, smithy_client_1.getArrayIfSingleItem)(output["Subnets"]["member"]), context);
+        contents.Subnets = de_Subnets((0, smithy_client_1.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 = (0, smithy_client_1.expectString)(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryDuplicateListenerException = (output, context) => {
+const de_DuplicateListenerException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = (0, smithy_client_1.expectString)(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryDuplicatePolicyNameException = (output, context) => {
+const de_DuplicatePolicyNameException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = (0, smithy_client_1.expectString)(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryDuplicateTagKeysException = (output, context) => {
+const de_DuplicateTagKeysException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = (0, smithy_client_1.expectString)(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryHealthCheck = (output, context) => {
+const de_HealthCheck = (output, context) => {
     const contents = {};
     if (output["Target"] !== undefined) {
         contents.Target = (0, smithy_client_1.expectString)(output["Target"]);
@@ -2909,21 +2909,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 = (0, smithy_client_1.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 = (0, smithy_client_1.expectString)(output["InstanceId"]);
@@ -2939,56 +2939,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 = (0, smithy_client_1.expectString)(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryInvalidEndPointException = (output, context) => {
+const de_InvalidEndPointException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = (0, smithy_client_1.expectString)(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryInvalidSchemeException = (output, context) => {
+const de_InvalidSchemeException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = (0, smithy_client_1.expectString)(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryInvalidSecurityGroupException = (output, context) => {
+const de_InvalidSecurityGroupException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = (0, smithy_client_1.expectString)(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryInvalidSubnetException = (output, context) => {
+const de_InvalidSubnetException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = (0, smithy_client_1.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 = (0, smithy_client_1.expectString)(output["PolicyName"]);
@@ -2998,7 +2998,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 = (0, smithy_client_1.expectString)(output["Name"]);
@@ -3008,14 +3008,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 = (0, smithy_client_1.expectString)(output["Protocol"]);
@@ -3034,63 +3034,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((0, smithy_client_1.getArrayIfSingleItem)(output["PolicyNames"]["member"]), context);
+        contents.PolicyNames = de_PolicyNames((0, smithy_client_1.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 = (0, smithy_client_1.expectString)(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryLoadBalancerAttributeNotFoundException = (output, context) => {
+const de_LoadBalancerAttributeNotFoundException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = (0, smithy_client_1.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((0, smithy_client_1.getArrayIfSingleItem)(output["AdditionalAttributes"]["member"]), context);
+        contents.AdditionalAttributes = de_AdditionalAttributes((0, smithy_client_1.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 = (0, smithy_client_1.expectString)(output["LoadBalancerName"]);
@@ -3108,29 +3108,29 @@ const deserializeAws_queryLoadBalancerDescription = (output, context) => {
         contents.ListenerDescriptions = [];
     }
     else if (output["ListenerDescriptions"] !== undefined && output["ListenerDescriptions"]["member"] !== undefined) {
-        contents.ListenerDescriptions = deserializeAws_queryListenerDescriptions((0, smithy_client_1.getArrayIfSingleItem)(output["ListenerDescriptions"]["member"]), context);
+        contents.ListenerDescriptions = de_ListenerDescriptions((0, smithy_client_1.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((0, smithy_client_1.getArrayIfSingleItem)(output["BackendServerDescriptions"]["member"]), context);
+        contents.BackendServerDescriptions = de_BackendServerDescriptions((0, smithy_client_1.getArrayIfSingleItem)(output["BackendServerDescriptions"]["member"]), context);
     }
     if (output.AvailabilityZones === "") {
         contents.AvailabilityZones = [];
     }
     else if (output["AvailabilityZones"] !== undefined && output["AvailabilityZones"]["member"] !== undefined) {
-        contents.AvailabilityZones = deserializeAws_queryAvailabilityZones((0, smithy_client_1.getArrayIfSingleItem)(output["AvailabilityZones"]["member"]), context);
+        contents.AvailabilityZones = de_AvailabilityZones((0, smithy_client_1.getArrayIfSingleItem)(output["AvailabilityZones"]["member"]), context);
     }
     if (output.Subnets === "") {
         contents.Subnets = [];
     }
     else if (output["Subnets"] !== undefined && output["Subnets"]["member"] !== undefined) {
-        contents.Subnets = deserializeAws_querySubnets((0, smithy_client_1.getArrayIfSingleItem)(output["Subnets"]["member"]), context);
+        contents.Subnets = de_Subnets((0, smithy_client_1.getArrayIfSingleItem)(output["Subnets"]["member"]), context);
     }
     if (output["VPCId"] !== undefined) {
         contents.VPCId = (0, smithy_client_1.expectString)(output["VPCId"]);
@@ -3139,19 +3139,19 @@ const deserializeAws_queryLoadBalancerDescription = (output, context) => {
         contents.Instances = [];
     }
     else if (output["Instances"] !== undefined && output["Instances"]["member"] !== undefined) {
-        contents.Instances = deserializeAws_queryInstances((0, smithy_client_1.getArrayIfSingleItem)(output["Instances"]["member"]), context);
+        contents.Instances = de_Instances((0, smithy_client_1.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((0, smithy_client_1.getArrayIfSingleItem)(output["SecurityGroups"]["member"]), context);
+        contents.SecurityGroups = de_SecurityGroups((0, smithy_client_1.getArrayIfSingleItem)(output["SecurityGroups"]["member"]), context);
     }
     if (output["CreatedTime"] !== undefined) {
         contents.CreatedTime = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["CreatedTime"]));
@@ -3161,55 +3161,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 = (0, smithy_client_1.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 = (0, smithy_client_1.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((0, smithy_client_1.getArrayIfSingleItem)(output["AppCookieStickinessPolicies"]["member"]), context);
+        contents.AppCookieStickinessPolicies = de_AppCookieStickinessPolicies((0, smithy_client_1.getArrayIfSingleItem)(output["AppCookieStickinessPolicies"]["member"]), context);
     }
     if (output.LBCookieStickinessPolicies === "") {
         contents.LBCookieStickinessPolicies = [];
     }
     else if (output["LBCookieStickinessPolicies"] !== undefined &&
         output["LBCookieStickinessPolicies"]["member"] !== undefined) {
-        contents.LBCookieStickinessPolicies = deserializeAws_queryLBCookieStickinessPolicies((0, smithy_client_1.getArrayIfSingleItem)(output["LBCookieStickinessPolicies"]["member"]), context);
+        contents.LBCookieStickinessPolicies = de_LBCookieStickinessPolicies((0, smithy_client_1.getArrayIfSingleItem)(output["LBCookieStickinessPolicies"]["member"]), context);
     }
     if (output.OtherPolicies === "") {
         contents.OtherPolicies = [];
     }
     else if (output["OtherPolicies"] !== undefined && output["OtherPolicies"]["member"] !== undefined) {
-        contents.OtherPolicies = deserializeAws_queryPolicyNames((0, smithy_client_1.getArrayIfSingleItem)(output["OtherPolicies"]["member"]), context);
+        contents.OtherPolicies = de_PolicyNames((0, smithy_client_1.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 = (0, smithy_client_1.expectString)(output["AttributeName"]);
@@ -3219,14 +3219,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 = (0, smithy_client_1.expectString)(output["AttributeName"]);
@@ -3245,14 +3245,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 = (0, smithy_client_1.expectString)(output["PolicyName"]);
@@ -3265,32 +3265,32 @@ const deserializeAws_queryPolicyDescription = (output, context) => {
     }
     else if (output["PolicyAttributeDescriptions"] !== undefined &&
         output["PolicyAttributeDescriptions"]["member"] !== undefined) {
-        contents.PolicyAttributeDescriptions = deserializeAws_queryPolicyAttributeDescriptions((0, smithy_client_1.getArrayIfSingleItem)(output["PolicyAttributeDescriptions"]["member"]), context);
+        contents.PolicyAttributeDescriptions = de_PolicyAttributeDescriptions((0, smithy_client_1.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 (0, smithy_client_1.expectString)(entry);
     });
 };
-const deserializeAws_queryPolicyNotFoundException = (output, context) => {
+const de_PolicyNotFoundException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = (0, smithy_client_1.expectString)(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryPolicyTypeDescription = (output, context) => {
+const de_PolicyTypeDescription = (output, context) => {
     const contents = {};
     if (output["PolicyTypeName"] !== undefined) {
         contents.PolicyTypeName = (0, smithy_client_1.expectString)(output["PolicyTypeName"]);
@@ -3303,68 +3303,68 @@ const deserializeAws_queryPolicyTypeDescription = (output, context) => {
     }
     else if (output["PolicyAttributeTypeDescriptions"] !== undefined &&
         output["PolicyAttributeTypeDescriptions"]["member"] !== undefined) {
-        contents.PolicyAttributeTypeDescriptions = deserializeAws_queryPolicyAttributeTypeDescriptions((0, smithy_client_1.getArrayIfSingleItem)(output["PolicyAttributeTypeDescriptions"]["member"]), context);
+        contents.PolicyAttributeTypeDescriptions = de_PolicyAttributeTypeDescriptions((0, smithy_client_1.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 = (0, smithy_client_1.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((0, smithy_client_1.getArrayIfSingleItem)(output["Instances"]["member"]), context);
+        contents.Instances = de_Instances((0, smithy_client_1.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((0, smithy_client_1.getArrayIfSingleItem)(output["AvailabilityZones"]["member"]), context);
+        contents.AvailabilityZones = de_AvailabilityZones((0, smithy_client_1.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 (0, smithy_client_1.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 = (0, smithy_client_1.expectString)(output["OwnerAlias"]);
@@ -3374,21 +3374,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 = (0, smithy_client_1.expectString)(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_querySubnets = (output, context) => {
+const de_Subnets = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         return (0, smithy_client_1.expectString)(entry);
     });
 };
-const deserializeAws_queryTag = (output, context) => {
+const de_Tag = (output, context) => {
     const contents = {};
     if (output["Key"] !== undefined) {
         contents.Key = (0, smithy_client_1.expectString)(output["Key"]);
@@ -3398,7 +3398,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 = (0, smithy_client_1.expectString)(output["LoadBalancerName"]);
@@ -3407,46 +3407,46 @@ const deserializeAws_queryTagDescription = (output, context) => {
         contents.Tags = [];
     }
     else if (output["Tags"] !== undefined && output["Tags"]["member"] !== undefined) {
-        contents.Tags = deserializeAws_queryTagList((0, smithy_client_1.getArrayIfSingleItem)(output["Tags"]["member"]), context);
+        contents.Tags = de_TagList((0, smithy_client_1.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 = (0, smithy_client_1.expectString)(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryTooManyPoliciesException = (output, context) => {
+const de_TooManyPoliciesException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = (0, smithy_client_1.expectString)(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryTooManyTagsException = (output, context) => {
+const de_TooManyTagsException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = (0, smithy_client_1.expectString)(output["Message"]);
     }
     return contents;
 };
-const deserializeAws_queryUnsupportedProtocolException = (output, context) => {
+const de_UnsupportedProtocolException = (output, context) => {
     const contents = {};
     if (output["Message"] !== undefined) {
         contents.Message = (0, smithy_client_1.expectString)(output["Message"]);