@aws-sdk/client-elastic-load-balancing 3.928.0 → 3.930.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 var utilWaiter = require('@smithy/util-waiter');
 
 const resolveClientEndpointParameters = (options) => {
@@ -92,6 +91,7 @@ class ElasticLoadBalancingClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -111,14 +111,14 @@ class ElasticLoadBalancingClient extends smithyClient.Client {
     }
 }
 
-class ElasticLoadBalancingServiceException extends smithyClient.ServiceException {
+let ElasticLoadBalancingServiceException$1 = class ElasticLoadBalancingServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, ElasticLoadBalancingServiceException.prototype);
     }
-}
+};
 
-class AccessPointNotFoundException extends ElasticLoadBalancingServiceException {
+let AccessPointNotFoundException$1 = class AccessPointNotFoundException extends ElasticLoadBalancingServiceException$1 {
     name = "AccessPointNotFoundException";
     $fault = "client";
     Message;
@@ -131,8 +131,8 @@ class AccessPointNotFoundException extends ElasticLoadBalancingServiceException
         Object.setPrototypeOf(this, AccessPointNotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
-class DuplicateTagKeysException extends ElasticLoadBalancingServiceException {
+};
+let DuplicateTagKeysException$1 = class DuplicateTagKeysException extends ElasticLoadBalancingServiceException$1 {
     name = "DuplicateTagKeysException";
     $fault = "client";
     Message;
@@ -145,8 +145,8 @@ class DuplicateTagKeysException extends ElasticLoadBalancingServiceException {
         Object.setPrototypeOf(this, DuplicateTagKeysException.prototype);
         this.Message = opts.Message;
     }
-}
-class TooManyTagsException extends ElasticLoadBalancingServiceException {
+};
+let TooManyTagsException$1 = class TooManyTagsException extends ElasticLoadBalancingServiceException$1 {
     name = "TooManyTagsException";
     $fault = "client";
     Message;
@@ -159,8 +159,8 @@ class TooManyTagsException extends ElasticLoadBalancingServiceException {
         Object.setPrototypeOf(this, TooManyTagsException.prototype);
         this.Message = opts.Message;
     }
-}
-class InvalidConfigurationRequestException extends ElasticLoadBalancingServiceException {
+};
+let InvalidConfigurationRequestException$1 = class InvalidConfigurationRequestException extends ElasticLoadBalancingServiceException$1 {
     name = "InvalidConfigurationRequestException";
     $fault = "client";
     Message;
@@ -173,8 +173,8 @@ class InvalidConfigurationRequestException extends ElasticLoadBalancingServiceEx
         Object.setPrototypeOf(this, InvalidConfigurationRequestException.prototype);
         this.Message = opts.Message;
     }
-}
-class InvalidSecurityGroupException extends ElasticLoadBalancingServiceException {
+};
+let InvalidSecurityGroupException$1 = class InvalidSecurityGroupException extends ElasticLoadBalancingServiceException$1 {
     name = "InvalidSecurityGroupException";
     $fault = "client";
     Message;
@@ -187,8 +187,8 @@ class InvalidSecurityGroupException extends ElasticLoadBalancingServiceException
         Object.setPrototypeOf(this, InvalidSecurityGroupException.prototype);
         this.Message = opts.Message;
     }
-}
-class InvalidSubnetException extends ElasticLoadBalancingServiceException {
+};
+let InvalidSubnetException$1 = class InvalidSubnetException extends ElasticLoadBalancingServiceException$1 {
     name = "InvalidSubnetException";
     $fault = "client";
     Message;
@@ -201,8 +201,8 @@ class InvalidSubnetException extends ElasticLoadBalancingServiceException {
         Object.setPrototypeOf(this, InvalidSubnetException.prototype);
         this.Message = opts.Message;
     }
-}
-class SubnetNotFoundException extends ElasticLoadBalancingServiceException {
+};
+let SubnetNotFoundException$1 = class SubnetNotFoundException extends ElasticLoadBalancingServiceException$1 {
     name = "SubnetNotFoundException";
     $fault = "client";
     Message;
@@ -215,8 +215,8 @@ class SubnetNotFoundException extends ElasticLoadBalancingServiceException {
         Object.setPrototypeOf(this, SubnetNotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
-class CertificateNotFoundException extends ElasticLoadBalancingServiceException {
+};
+let CertificateNotFoundException$1 = class CertificateNotFoundException extends ElasticLoadBalancingServiceException$1 {
     name = "CertificateNotFoundException";
     $fault = "client";
     Message;
@@ -229,8 +229,8 @@ class CertificateNotFoundException extends ElasticLoadBalancingServiceException
         Object.setPrototypeOf(this, CertificateNotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
-class DuplicatePolicyNameException extends ElasticLoadBalancingServiceException {
+};
+let DuplicatePolicyNameException$1 = class DuplicatePolicyNameException extends ElasticLoadBalancingServiceException$1 {
     name = "DuplicatePolicyNameException";
     $fault = "client";
     Message;
@@ -243,8 +243,8 @@ class DuplicatePolicyNameException extends ElasticLoadBalancingServiceException
         Object.setPrototypeOf(this, DuplicatePolicyNameException.prototype);
         this.Message = opts.Message;
     }
-}
-class TooManyPoliciesException extends ElasticLoadBalancingServiceException {
+};
+let TooManyPoliciesException$1 = class TooManyPoliciesException extends ElasticLoadBalancingServiceException$1 {
     name = "TooManyPoliciesException";
     $fault = "client";
     Message;
@@ -257,8 +257,8 @@ class TooManyPoliciesException extends ElasticLoadBalancingServiceException {
         Object.setPrototypeOf(this, TooManyPoliciesException.prototype);
         this.Message = opts.Message;
     }
-}
-class DuplicateAccessPointNameException extends ElasticLoadBalancingServiceException {
+};
+let DuplicateAccessPointNameException$1 = class DuplicateAccessPointNameException extends ElasticLoadBalancingServiceException$1 {
     name = "DuplicateAccessPointNameException";
     $fault = "client";
     Message;
@@ -271,8 +271,8 @@ class DuplicateAccessPointNameException extends ElasticLoadBalancingServiceExcep
         Object.setPrototypeOf(this, DuplicateAccessPointNameException.prototype);
         this.Message = opts.Message;
     }
-}
-class InvalidSchemeException extends ElasticLoadBalancingServiceException {
+};
+let InvalidSchemeException$1 = class InvalidSchemeException extends ElasticLoadBalancingServiceException$1 {
     name = "InvalidSchemeException";
     $fault = "client";
     Message;
@@ -285,8 +285,8 @@ class InvalidSchemeException extends ElasticLoadBalancingServiceException {
         Object.setPrototypeOf(this, InvalidSchemeException.prototype);
         this.Message = opts.Message;
     }
-}
-class OperationNotPermittedException extends ElasticLoadBalancingServiceException {
+};
+let OperationNotPermittedException$1 = class OperationNotPermittedException extends ElasticLoadBalancingServiceException$1 {
     name = "OperationNotPermittedException";
     $fault = "client";
     Message;
@@ -299,8 +299,8 @@ class OperationNotPermittedException extends ElasticLoadBalancingServiceExceptio
         Object.setPrototypeOf(this, OperationNotPermittedException.prototype);
         this.Message = opts.Message;
     }
-}
-class TooManyAccessPointsException extends ElasticLoadBalancingServiceException {
+};
+let TooManyAccessPointsException$1 = class TooManyAccessPointsException extends ElasticLoadBalancingServiceException$1 {
     name = "TooManyAccessPointsException";
     $fault = "client";
     Message;
@@ -313,8 +313,8 @@ class TooManyAccessPointsException extends ElasticLoadBalancingServiceException
         Object.setPrototypeOf(this, TooManyAccessPointsException.prototype);
         this.Message = opts.Message;
     }
-}
-class UnsupportedProtocolException extends ElasticLoadBalancingServiceException {
+};
+let UnsupportedProtocolException$1 = class UnsupportedProtocolException extends ElasticLoadBalancingServiceException$1 {
     name = "UnsupportedProtocolException";
     $fault = "client";
     Message;
@@ -327,8 +327,8 @@ class UnsupportedProtocolException extends ElasticLoadBalancingServiceException
         Object.setPrototypeOf(this, UnsupportedProtocolException.prototype);
         this.Message = opts.Message;
     }
-}
-class DuplicateListenerException extends ElasticLoadBalancingServiceException {
+};
+let DuplicateListenerException$1 = class DuplicateListenerException extends ElasticLoadBalancingServiceException$1 {
     name = "DuplicateListenerException";
     $fault = "client";
     Message;
@@ -341,8 +341,8 @@ class DuplicateListenerException extends ElasticLoadBalancingServiceException {
         Object.setPrototypeOf(this, DuplicateListenerException.prototype);
         this.Message = opts.Message;
     }
-}
-class PolicyTypeNotFoundException extends ElasticLoadBalancingServiceException {
+};
+let PolicyTypeNotFoundException$1 = class PolicyTypeNotFoundException extends ElasticLoadBalancingServiceException$1 {
     name = "PolicyTypeNotFoundException";
     $fault = "client";
     Message;
@@ -355,8 +355,8 @@ class PolicyTypeNotFoundException extends ElasticLoadBalancingServiceException {
         Object.setPrototypeOf(this, PolicyTypeNotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
-class DependencyThrottleException extends ElasticLoadBalancingServiceException {
+};
+let DependencyThrottleException$1 = class DependencyThrottleException extends ElasticLoadBalancingServiceException$1 {
     name = "DependencyThrottleException";
     $fault = "client";
     Message;
@@ -369,8 +369,8 @@ class DependencyThrottleException extends ElasticLoadBalancingServiceException {
         Object.setPrototypeOf(this, DependencyThrottleException.prototype);
         this.Message = opts.Message;
     }
-}
-class InvalidEndPointException extends ElasticLoadBalancingServiceException {
+};
+let InvalidEndPointException$1 = class InvalidEndPointException extends ElasticLoadBalancingServiceException$1 {
     name = "InvalidEndPointException";
     $fault = "client";
     Message;
@@ -383,8 +383,8 @@ class InvalidEndPointException extends ElasticLoadBalancingServiceException {
         Object.setPrototypeOf(this, InvalidEndPointException.prototype);
         this.Message = opts.Message;
     }
-}
-class LoadBalancerAttributeNotFoundException extends ElasticLoadBalancingServiceException {
+};
+let LoadBalancerAttributeNotFoundException$1 = class LoadBalancerAttributeNotFoundException extends ElasticLoadBalancingServiceException$1 {
     name = "LoadBalancerAttributeNotFoundException";
     $fault = "client";
     Message;
@@ -397,8 +397,8 @@ class LoadBalancerAttributeNotFoundException extends ElasticLoadBalancingService
         Object.setPrototypeOf(this, LoadBalancerAttributeNotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
-class PolicyNotFoundException extends ElasticLoadBalancingServiceException {
+};
+let PolicyNotFoundException$1 = class PolicyNotFoundException extends ElasticLoadBalancingServiceException$1 {
     name = "PolicyNotFoundException";
     $fault = "client";
     Message;
@@ -411,8 +411,8 @@ class PolicyNotFoundException extends ElasticLoadBalancingServiceException {
         Object.setPrototypeOf(this, PolicyNotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
-class ListenerNotFoundException extends ElasticLoadBalancingServiceException {
+};
+let ListenerNotFoundException$1 = class ListenerNotFoundException extends ElasticLoadBalancingServiceException$1 {
     name = "ListenerNotFoundException";
     $fault = "client";
     Message;
@@ -425,2757 +425,103 @@ class ListenerNotFoundException extends ElasticLoadBalancingServiceException {
         Object.setPrototypeOf(this, ListenerNotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
-
-const se_AddTagsCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_AddTagsInput(input),
-        [_A]: _AT,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ApplySecurityGroupsToLoadBalancerCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_ApplySecurityGroupsToLoadBalancerInput(input),
-        [_A]: _ASGTLB,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_AttachLoadBalancerToSubnetsCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_AttachLoadBalancerToSubnetsInput(input),
-        [_A]: _ALBTS,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ConfigureHealthCheckCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_ConfigureHealthCheckInput(input),
-        [_A]: _CHC,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateAppCookieStickinessPolicyCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_CreateAppCookieStickinessPolicyInput(input),
-        [_A]: _CACSP,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateLBCookieStickinessPolicyCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_CreateLBCookieStickinessPolicyInput(input),
-        [_A]: _CLBCSP,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateLoadBalancerCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_CreateAccessPointInput(input),
-        [_A]: _CLB,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateLoadBalancerListenersCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_CreateLoadBalancerListenerInput(input),
-        [_A]: _CLBL,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateLoadBalancerPolicyCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_CreateLoadBalancerPolicyInput(input),
-        [_A]: _CLBP,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteLoadBalancerCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_DeleteAccessPointInput(input),
-        [_A]: _DLB,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteLoadBalancerListenersCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_DeleteLoadBalancerListenerInput(input),
-        [_A]: _DLBL,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteLoadBalancerPolicyCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_DeleteLoadBalancerPolicyInput(input),
-        [_A]: _DLBP,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeregisterInstancesFromLoadBalancerCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_DeregisterEndPointsInput(input),
-        [_A]: _DIFLB,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeAccountLimitsCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_DescribeAccountLimitsInput(input),
-        [_A]: _DAL,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeInstanceHealthCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_DescribeEndPointStateInput(input),
-        [_A]: _DIH,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeLoadBalancerAttributesCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_DescribeLoadBalancerAttributesInput(input),
-        [_A]: _DLBA,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeLoadBalancerPoliciesCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_DescribeLoadBalancerPoliciesInput(input),
-        [_A]: _DLBPe,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeLoadBalancerPolicyTypesCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_DescribeLoadBalancerPolicyTypesInput(input),
-        [_A]: _DLBPT,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeLoadBalancersCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_DescribeAccessPointsInput(input),
-        [_A]: _DLBe,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeTagsCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_DescribeTagsInput(input),
-        [_A]: _DT,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DetachLoadBalancerFromSubnetsCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_DetachLoadBalancerFromSubnetsInput(input),
-        [_A]: _DLBFS,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DisableAvailabilityZonesForLoadBalancerCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_RemoveAvailabilityZonesInput(input),
-        [_A]: _DAZFLB,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_EnableAvailabilityZonesForLoadBalancerCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_AddAvailabilityZonesInput(input),
-        [_A]: _EAZFLB,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ModifyLoadBalancerAttributesCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_ModifyLoadBalancerAttributesInput(input),
-        [_A]: _MLBA,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RegisterInstancesWithLoadBalancerCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_RegisterEndPointsInput(input),
-        [_A]: _RIWLB,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RemoveTagsCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_RemoveTagsInput(input),
-        [_A]: _RT,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_SetLoadBalancerListenerSSLCertificateCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_SetLoadBalancerListenerSSLCertificateInput(input),
-        [_A]: _SLBLSSLC,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_SetLoadBalancerPoliciesForBackendServerCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_SetLoadBalancerPoliciesForBackendServerInput(input),
-        [_A]: _SLBPFBS,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_SetLoadBalancerPoliciesOfListenerCommand = async (input, context) => {
-    const headers = SHARED_HEADERS;
-    let body;
-    body = buildFormUrlencodedString({
-        ...se_SetLoadBalancerPoliciesOfListenerInput(input),
-        [_A]: _SLBPOL,
-        [_V]: _,
-    });
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_AddTagsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_AddTagsOutput(data.AddTagsResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ApplySecurityGroupsToLoadBalancerCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_ApplySecurityGroupsToLoadBalancerOutput(data.ApplySecurityGroupsToLoadBalancerResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_AttachLoadBalancerToSubnetsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_AttachLoadBalancerToSubnetsOutput(data.AttachLoadBalancerToSubnetsResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ConfigureHealthCheckCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_ConfigureHealthCheckOutput(data.ConfigureHealthCheckResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateAppCookieStickinessPolicyCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_CreateAppCookieStickinessPolicyOutput(data.CreateAppCookieStickinessPolicyResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateLBCookieStickinessPolicyCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_CreateLBCookieStickinessPolicyOutput(data.CreateLBCookieStickinessPolicyResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateLoadBalancerCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_CreateAccessPointOutput(data.CreateLoadBalancerResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateLoadBalancerListenersCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_CreateLoadBalancerListenerOutput(data.CreateLoadBalancerListenersResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateLoadBalancerPolicyCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_CreateLoadBalancerPolicyOutput(data.CreateLoadBalancerPolicyResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteLoadBalancerCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_DeleteAccessPointOutput(data.DeleteLoadBalancerResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteLoadBalancerListenersCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_DeleteLoadBalancerListenerOutput(data.DeleteLoadBalancerListenersResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteLoadBalancerPolicyCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_DeleteLoadBalancerPolicyOutput(data.DeleteLoadBalancerPolicyResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeregisterInstancesFromLoadBalancerCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_DeregisterEndPointsOutput(data.DeregisterInstancesFromLoadBalancerResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeAccountLimitsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeAccountLimitsOutput(data.DescribeAccountLimitsResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeInstanceHealthCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeEndPointStateOutput(data.DescribeInstanceHealthResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeLoadBalancerAttributesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeLoadBalancerAttributesOutput(data.DescribeLoadBalancerAttributesResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeLoadBalancerPoliciesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeLoadBalancerPoliciesOutput(data.DescribeLoadBalancerPoliciesResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeLoadBalancerPolicyTypesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeLoadBalancerPolicyTypesOutput(data.DescribeLoadBalancerPolicyTypesResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeLoadBalancersCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeAccessPointsOutput(data.DescribeLoadBalancersResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeTagsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeTagsOutput(data.DescribeTagsResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DetachLoadBalancerFromSubnetsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_DetachLoadBalancerFromSubnetsOutput(data.DetachLoadBalancerFromSubnetsResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DisableAvailabilityZonesForLoadBalancerCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_RemoveAvailabilityZonesOutput(data.DisableAvailabilityZonesForLoadBalancerResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_EnableAvailabilityZonesForLoadBalancerCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_AddAvailabilityZonesOutput(data.EnableAvailabilityZonesForLoadBalancerResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ModifyLoadBalancerAttributesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_ModifyLoadBalancerAttributesOutput(data.ModifyLoadBalancerAttributesResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_RegisterInstancesWithLoadBalancerCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_RegisterEndPointsOutput(data.RegisterInstancesWithLoadBalancerResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_RemoveTagsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_RemoveTagsOutput(data.RemoveTagsResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_SetLoadBalancerListenerSSLCertificateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_SetLoadBalancerListenerSSLCertificateOutput(data.SetLoadBalancerListenerSSLCertificateResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_SetLoadBalancerPoliciesForBackendServerCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_SetLoadBalancerPoliciesForBackendServerOutput(data.SetLoadBalancerPoliciesForBackendServerResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_SetLoadBalancerPoliciesOfListenerCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseXmlBody(output.body, context);
-    let contents = {};
-    contents = de_SetLoadBalancerPoliciesOfListenerOutput(data.SetLoadBalancerPoliciesOfListenerResult);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseXmlErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "DuplicateTagKeys":
-        case "com.amazonaws.elasticloadbalancing#DuplicateTagKeysException":
-            throw await de_DuplicateTagKeysExceptionRes(parsedOutput);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput);
-        case "TooManyTags":
-        case "com.amazonaws.elasticloadbalancing#TooManyTagsException":
-            throw await de_TooManyTagsExceptionRes(parsedOutput);
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput);
-        case "InvalidSecurityGroup":
-        case "com.amazonaws.elasticloadbalancing#InvalidSecurityGroupException":
-            throw await de_InvalidSecurityGroupExceptionRes(parsedOutput);
-        case "InvalidSubnet":
-        case "com.amazonaws.elasticloadbalancing#InvalidSubnetException":
-            throw await de_InvalidSubnetExceptionRes(parsedOutput);
-        case "SubnetNotFound":
-        case "com.amazonaws.elasticloadbalancing#SubnetNotFoundException":
-            throw await de_SubnetNotFoundExceptionRes(parsedOutput);
-        case "DuplicatePolicyName":
-        case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException":
-            throw await de_DuplicatePolicyNameExceptionRes(parsedOutput);
-        case "TooManyPolicies":
-        case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException":
-            throw await de_TooManyPoliciesExceptionRes(parsedOutput);
-        case "CertificateNotFound":
-        case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException":
-            throw await de_CertificateNotFoundExceptionRes(parsedOutput);
-        case "DuplicateLoadBalancerName":
-        case "com.amazonaws.elasticloadbalancing#DuplicateAccessPointNameException":
-            throw await de_DuplicateAccessPointNameExceptionRes(parsedOutput);
-        case "InvalidScheme":
-        case "com.amazonaws.elasticloadbalancing#InvalidSchemeException":
-            throw await de_InvalidSchemeExceptionRes(parsedOutput);
-        case "OperationNotPermitted":
-        case "com.amazonaws.elasticloadbalancing#OperationNotPermittedException":
-            throw await de_OperationNotPermittedExceptionRes(parsedOutput);
-        case "TooManyLoadBalancers":
-        case "com.amazonaws.elasticloadbalancing#TooManyAccessPointsException":
-            throw await de_TooManyAccessPointsExceptionRes(parsedOutput);
-        case "UnsupportedProtocol":
-        case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException":
-            throw await de_UnsupportedProtocolExceptionRes(parsedOutput);
-        case "DuplicateListener":
-        case "com.amazonaws.elasticloadbalancing#DuplicateListenerException":
-            throw await de_DuplicateListenerExceptionRes(parsedOutput);
-        case "PolicyTypeNotFound":
-        case "com.amazonaws.elasticloadbalancing#PolicyTypeNotFoundException":
-            throw await de_PolicyTypeNotFoundExceptionRes(parsedOutput);
-        case "InvalidInstance":
-        case "com.amazonaws.elasticloadbalancing#InvalidEndPointException":
-            throw await de_InvalidEndPointExceptionRes(parsedOutput);
-        case "LoadBalancerAttributeNotFound":
-        case "com.amazonaws.elasticloadbalancing#LoadBalancerAttributeNotFoundException":
-            throw await de_LoadBalancerAttributeNotFoundExceptionRes(parsedOutput);
-        case "PolicyNotFound":
-        case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException":
-            throw await de_PolicyNotFoundExceptionRes(parsedOutput);
-        case "DependencyThrottle":
-        case "com.amazonaws.elasticloadbalancing#DependencyThrottleException":
-            throw await de_DependencyThrottleExceptionRes(parsedOutput);
-        case "ListenerNotFound":
-        case "com.amazonaws.elasticloadbalancing#ListenerNotFoundException":
-            throw await de_ListenerNotFoundExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-const de_AccessPointNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_AccessPointNotFoundException(body.Error);
-    const exception = new AccessPointNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_CertificateNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_CertificateNotFoundException(body.Error);
-    const exception = new CertificateNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_DependencyThrottleExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_DependencyThrottleException(body.Error);
-    const exception = new DependencyThrottleException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_DuplicateAccessPointNameExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_DuplicateAccessPointNameException(body.Error);
-    const exception = new DuplicateAccessPointNameException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_DuplicateListenerExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_DuplicateListenerException(body.Error);
-    const exception = new DuplicateListenerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_DuplicatePolicyNameExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_DuplicatePolicyNameException(body.Error);
-    const exception = new DuplicatePolicyNameException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_DuplicateTagKeysExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_DuplicateTagKeysException(body.Error);
-    const exception = new DuplicateTagKeysException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidConfigurationRequestExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_InvalidConfigurationRequestException(body.Error);
-    const exception = new InvalidConfigurationRequestException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidEndPointExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_InvalidEndPointException(body.Error);
-    const exception = new InvalidEndPointException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidSchemeExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_InvalidSchemeException(body.Error);
-    const exception = new InvalidSchemeException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidSecurityGroupExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_InvalidSecurityGroupException(body.Error);
-    const exception = new InvalidSecurityGroupException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidSubnetExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_InvalidSubnetException(body.Error);
-    const exception = new InvalidSubnetException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ListenerNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_ListenerNotFoundException(body.Error);
-    const exception = new ListenerNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_LoadBalancerAttributeNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_LoadBalancerAttributeNotFoundException(body.Error);
-    const exception = new LoadBalancerAttributeNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_OperationNotPermittedExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_OperationNotPermittedException(body.Error);
-    const exception = new OperationNotPermittedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_PolicyNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_PolicyNotFoundException(body.Error);
-    const exception = new PolicyNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_PolicyTypeNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_PolicyTypeNotFoundException(body.Error);
-    const exception = new PolicyTypeNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_SubnetNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_SubnetNotFoundException(body.Error);
-    const exception = new SubnetNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_TooManyAccessPointsExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_TooManyAccessPointsException(body.Error);
-    const exception = new TooManyAccessPointsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_TooManyPoliciesExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_TooManyPoliciesException(body.Error);
-    const exception = new TooManyPoliciesException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_TooManyTagsExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_TooManyTagsException(body.Error);
-    const exception = new TooManyTagsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_UnsupportedProtocolExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = de_UnsupportedProtocolException(body.Error);
-    const exception = new UnsupportedProtocolException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const se_AccessLog = (input, context) => {
-    const entries = {};
-    if (input[_E] != null) {
-        entries[_E] = input[_E];
-    }
-    if (input[_SBN] != null) {
-        entries[_SBN] = input[_SBN];
-    }
-    if (input[_EI] != null) {
-        entries[_EI] = input[_EI];
-    }
-    if (input[_SBP] != null) {
-        entries[_SBP] = input[_SBP];
-    }
-    return entries;
-};
-const se_AddAvailabilityZonesInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_AZ] != null) {
-        const memberEntries = se_AvailabilityZones(input[_AZ]);
-        if (input[_AZ]?.length === 0) {
-            entries.AvailabilityZones = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `AvailabilityZones.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_AdditionalAttribute = (input, context) => {
-    const entries = {};
-    if (input[_K] != null) {
-        entries[_K] = input[_K];
-    }
-    if (input[_Va] != null) {
-        entries[_Va] = input[_Va];
-    }
-    return entries;
-};
-const se_AdditionalAttributes = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
-        }
-        const memberEntries = se_AdditionalAttribute(entry);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            entries[`member.${counter}.${key}`] = value;
-        });
-        counter++;
-    }
-    return entries;
 };
-const se_AddTagsInput = (input, context) => {
-    const entries = {};
-    if (input[_LBNo] != null) {
-        const memberEntries = se_LoadBalancerNames(input[_LBNo]);
-        if (input[_LBNo]?.length === 0) {
-            entries.LoadBalancerNames = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `LoadBalancerNames.${key}`;
-            entries[loc] = value;
-        });
-    }
-    if (input[_T] != null) {
-        const memberEntries = se_TagList(input[_T]);
-        if (input[_T]?.length === 0) {
-            entries.Tags = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Tags.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_ApplySecurityGroupsToLoadBalancerInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_SG] != null) {
-        const memberEntries = se_SecurityGroups(input[_SG]);
-        if (input[_SG]?.length === 0) {
-            entries.SecurityGroups = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `SecurityGroups.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_AttachLoadBalancerToSubnetsInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_S] != null) {
-        const memberEntries = se_Subnets(input[_S]);
-        if (input[_S]?.length === 0) {
-            entries.Subnets = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Subnets.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_AvailabilityZones = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
-        }
-        entries[`member.${counter}`] = entry;
-        counter++;
-    }
-    return entries;
-};
-const se_ConfigureHealthCheckInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_HC] != null) {
-        const memberEntries = se_HealthCheck(input[_HC]);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `HealthCheck.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_ConnectionDraining = (input, context) => {
-    const entries = {};
-    if (input[_E] != null) {
-        entries[_E] = input[_E];
-    }
-    if (input[_Ti] != null) {
-        entries[_Ti] = input[_Ti];
-    }
-    return entries;
-};
-const se_ConnectionSettings = (input, context) => {
-    const entries = {};
-    if (input[_IT] != null) {
-        entries[_IT] = input[_IT];
-    }
-    return entries;
-};
-const se_CreateAccessPointInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_L] != null) {
-        const memberEntries = se_Listeners(input[_L]);
-        if (input[_L]?.length === 0) {
-            entries.Listeners = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Listeners.${key}`;
-            entries[loc] = value;
-        });
-    }
-    if (input[_AZ] != null) {
-        const memberEntries = se_AvailabilityZones(input[_AZ]);
-        if (input[_AZ]?.length === 0) {
-            entries.AvailabilityZones = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `AvailabilityZones.${key}`;
-            entries[loc] = value;
-        });
-    }
-    if (input[_S] != null) {
-        const memberEntries = se_Subnets(input[_S]);
-        if (input[_S]?.length === 0) {
-            entries.Subnets = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Subnets.${key}`;
-            entries[loc] = value;
-        });
-    }
-    if (input[_SG] != null) {
-        const memberEntries = se_SecurityGroups(input[_SG]);
-        if (input[_SG]?.length === 0) {
-            entries.SecurityGroups = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `SecurityGroups.${key}`;
-            entries[loc] = value;
-        });
-    }
-    if (input[_Sc] != null) {
-        entries[_Sc] = input[_Sc];
-    }
-    if (input[_T] != null) {
-        const memberEntries = se_TagList(input[_T]);
-        if (input[_T]?.length === 0) {
-            entries.Tags = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Tags.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_CreateAppCookieStickinessPolicyInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_PN] != null) {
-        entries[_PN] = input[_PN];
-    }
-    if (input[_CN] != null) {
-        entries[_CN] = input[_CN];
-    }
-    return entries;
-};
-const se_CreateLBCookieStickinessPolicyInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_PN] != null) {
-        entries[_PN] = input[_PN];
-    }
-    if (input[_CEP] != null) {
-        entries[_CEP] = input[_CEP];
-    }
-    return entries;
-};
-const se_CreateLoadBalancerListenerInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_L] != null) {
-        const memberEntries = se_Listeners(input[_L]);
-        if (input[_L]?.length === 0) {
-            entries.Listeners = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Listeners.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_CreateLoadBalancerPolicyInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_PN] != null) {
-        entries[_PN] = input[_PN];
-    }
-    if (input[_PTN] != null) {
-        entries[_PTN] = input[_PTN];
-    }
-    if (input[_PA] != null) {
-        const memberEntries = se_PolicyAttributes(input[_PA]);
-        if (input[_PA]?.length === 0) {
-            entries.PolicyAttributes = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `PolicyAttributes.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_CrossZoneLoadBalancing = (input, context) => {
-    const entries = {};
-    if (input[_E] != null) {
-        entries[_E] = input[_E];
-    }
-    return entries;
-};
-const se_DeleteAccessPointInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    return entries;
-};
-const se_DeleteLoadBalancerListenerInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_LBP] != null) {
-        const memberEntries = se_Ports(input[_LBP]);
-        if (input[_LBP]?.length === 0) {
-            entries.LoadBalancerPorts = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `LoadBalancerPorts.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_DeleteLoadBalancerPolicyInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_PN] != null) {
-        entries[_PN] = input[_PN];
-    }
-    return entries;
-};
-const se_DeregisterEndPointsInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_I] != null) {
-        const memberEntries = se_Instances(input[_I]);
-        if (input[_I]?.length === 0) {
-            entries.Instances = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Instances.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_DescribeAccessPointsInput = (input, context) => {
-    const entries = {};
-    if (input[_LBNo] != null) {
-        const memberEntries = se_LoadBalancerNames(input[_LBNo]);
-        if (input[_LBNo]?.length === 0) {
-            entries.LoadBalancerNames = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `LoadBalancerNames.${key}`;
-            entries[loc] = value;
-        });
-    }
-    if (input[_M] != null) {
-        entries[_M] = input[_M];
-    }
-    if (input[_PS] != null) {
-        entries[_PS] = input[_PS];
-    }
-    return entries;
-};
-const se_DescribeAccountLimitsInput = (input, context) => {
-    const entries = {};
-    if (input[_M] != null) {
-        entries[_M] = input[_M];
-    }
-    if (input[_PS] != null) {
-        entries[_PS] = input[_PS];
-    }
-    return entries;
-};
-const se_DescribeEndPointStateInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_I] != null) {
-        const memberEntries = se_Instances(input[_I]);
-        if (input[_I]?.length === 0) {
-            entries.Instances = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Instances.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_DescribeLoadBalancerAttributesInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    return entries;
-};
-const se_DescribeLoadBalancerPoliciesInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_PNo] != null) {
-        const memberEntries = se_PolicyNames(input[_PNo]);
-        if (input[_PNo]?.length === 0) {
-            entries.PolicyNames = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `PolicyNames.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_DescribeLoadBalancerPolicyTypesInput = (input, context) => {
-    const entries = {};
-    if (input[_PTNo] != null) {
-        const memberEntries = se_PolicyTypeNames(input[_PTNo]);
-        if (input[_PTNo]?.length === 0) {
-            entries.PolicyTypeNames = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `PolicyTypeNames.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_DescribeTagsInput = (input, context) => {
-    const entries = {};
-    if (input[_LBNo] != null) {
-        const memberEntries = se_LoadBalancerNamesMax20(input[_LBNo]);
-        if (input[_LBNo]?.length === 0) {
-            entries.LoadBalancerNames = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `LoadBalancerNames.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_DetachLoadBalancerFromSubnetsInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_S] != null) {
-        const memberEntries = se_Subnets(input[_S]);
-        if (input[_S]?.length === 0) {
-            entries.Subnets = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Subnets.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_HealthCheck = (input, context) => {
-    const entries = {};
-    if (input[_Ta] != null) {
-        entries[_Ta] = input[_Ta];
-    }
-    if (input[_In] != null) {
-        entries[_In] = input[_In];
-    }
-    if (input[_Ti] != null) {
-        entries[_Ti] = input[_Ti];
-    }
-    if (input[_UT] != null) {
-        entries[_UT] = input[_UT];
-    }
-    if (input[_HT] != null) {
-        entries[_HT] = input[_HT];
-    }
-    return entries;
-};
-const se_Instance = (input, context) => {
-    const entries = {};
-    if (input[_II] != null) {
-        entries[_II] = input[_II];
-    }
-    return entries;
-};
-const se_Instances = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
-        }
-        const memberEntries = se_Instance(entry);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            entries[`member.${counter}.${key}`] = value;
-        });
-        counter++;
-    }
-    return entries;
-};
-const se_Listener = (input, context) => {
-    const entries = {};
-    if (input[_P] != null) {
-        entries[_P] = input[_P];
-    }
-    if (input[_LBPo] != null) {
-        entries[_LBPo] = input[_LBPo];
-    }
-    if (input[_IP] != null) {
-        entries[_IP] = input[_IP];
-    }
-    if (input[_IPn] != null) {
-        entries[_IPn] = input[_IPn];
-    }
-    if (input[_SSLCI] != null) {
-        entries[_SSLCI] = input[_SSLCI];
-    }
-    return entries;
-};
-const se_Listeners = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
-        }
-        const memberEntries = se_Listener(entry);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            entries[`member.${counter}.${key}`] = value;
-        });
-        counter++;
-    }
-    return entries;
-};
-const se_LoadBalancerAttributes = (input, context) => {
-    const entries = {};
-    if (input[_CZLB] != null) {
-        const memberEntries = se_CrossZoneLoadBalancing(input[_CZLB]);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `CrossZoneLoadBalancing.${key}`;
-            entries[loc] = value;
-        });
-    }
-    if (input[_AL] != null) {
-        const memberEntries = se_AccessLog(input[_AL]);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `AccessLog.${key}`;
-            entries[loc] = value;
-        });
-    }
-    if (input[_CD] != null) {
-        const memberEntries = se_ConnectionDraining(input[_CD]);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `ConnectionDraining.${key}`;
-            entries[loc] = value;
-        });
-    }
-    if (input[_CS] != null) {
-        const memberEntries = se_ConnectionSettings(input[_CS]);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `ConnectionSettings.${key}`;
-            entries[loc] = value;
-        });
-    }
-    if (input[_AA] != null) {
-        const memberEntries = se_AdditionalAttributes(input[_AA]);
-        if (input[_AA]?.length === 0) {
-            entries.AdditionalAttributes = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `AdditionalAttributes.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_LoadBalancerNames = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
-        }
-        entries[`member.${counter}`] = entry;
-        counter++;
-    }
-    return entries;
-};
-const se_LoadBalancerNamesMax20 = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
-        }
-        entries[`member.${counter}`] = entry;
-        counter++;
-    }
-    return entries;
-};
-const se_ModifyLoadBalancerAttributesInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_LBA] != null) {
-        const memberEntries = se_LoadBalancerAttributes(input[_LBA]);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `LoadBalancerAttributes.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_PolicyAttribute = (input, context) => {
-    const entries = {};
-    if (input[_AN] != null) {
-        entries[_AN] = input[_AN];
-    }
-    if (input[_AV] != null) {
-        entries[_AV] = input[_AV];
-    }
-    return entries;
-};
-const se_PolicyAttributes = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
-        }
-        const memberEntries = se_PolicyAttribute(entry);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            entries[`member.${counter}.${key}`] = value;
-        });
-        counter++;
-    }
-    return entries;
-};
-const se_PolicyNames = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
-        }
-        entries[`member.${counter}`] = entry;
-        counter++;
-    }
-    return entries;
-};
-const se_PolicyTypeNames = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
-        }
-        entries[`member.${counter}`] = entry;
-        counter++;
-    }
-    return entries;
-};
-const se_Ports = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
-        }
-        entries[`member.${counter}`] = entry;
-        counter++;
-    }
-    return entries;
-};
-const se_RegisterEndPointsInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_I] != null) {
-        const memberEntries = se_Instances(input[_I]);
-        if (input[_I]?.length === 0) {
-            entries.Instances = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Instances.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_RemoveAvailabilityZonesInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_AZ] != null) {
-        const memberEntries = se_AvailabilityZones(input[_AZ]);
-        if (input[_AZ]?.length === 0) {
-            entries.AvailabilityZones = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `AvailabilityZones.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_RemoveTagsInput = (input, context) => {
-    const entries = {};
-    if (input[_LBNo] != null) {
-        const memberEntries = se_LoadBalancerNames(input[_LBNo]);
-        if (input[_LBNo]?.length === 0) {
-            entries.LoadBalancerNames = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `LoadBalancerNames.${key}`;
-            entries[loc] = value;
-        });
-    }
-    if (input[_T] != null) {
-        const memberEntries = se_TagKeyList(input[_T]);
-        if (input[_T]?.length === 0) {
-            entries.Tags = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Tags.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_SecurityGroups = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
-        }
-        entries[`member.${counter}`] = entry;
-        counter++;
-    }
-    return entries;
-};
-const se_SetLoadBalancerListenerSSLCertificateInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_LBPo] != null) {
-        entries[_LBPo] = input[_LBPo];
-    }
-    if (input[_SSLCI] != null) {
-        entries[_SSLCI] = input[_SSLCI];
-    }
-    return entries;
-};
-const se_SetLoadBalancerPoliciesForBackendServerInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_IPn] != null) {
-        entries[_IPn] = input[_IPn];
-    }
-    if (input[_PNo] != null) {
-        const memberEntries = se_PolicyNames(input[_PNo]);
-        if (input[_PNo]?.length === 0) {
-            entries.PolicyNames = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `PolicyNames.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_SetLoadBalancerPoliciesOfListenerInput = (input, context) => {
-    const entries = {};
-    if (input[_LBN] != null) {
-        entries[_LBN] = input[_LBN];
-    }
-    if (input[_LBPo] != null) {
-        entries[_LBPo] = input[_LBPo];
-    }
-    if (input[_PNo] != null) {
-        const memberEntries = se_PolicyNames(input[_PNo]);
-        if (input[_PNo]?.length === 0) {
-            entries.PolicyNames = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `PolicyNames.${key}`;
-            entries[loc] = value;
-        });
-    }
-    return entries;
-};
-const se_Subnets = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
-        }
-        entries[`member.${counter}`] = entry;
-        counter++;
-    }
-    return entries;
-};
-const se_Tag = (input, context) => {
-    const entries = {};
-    if (input[_K] != null) {
-        entries[_K] = input[_K];
-    }
-    if (input[_Va] != null) {
-        entries[_Va] = input[_Va];
-    }
-    return entries;
-};
-const se_TagKeyList = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
-        }
-        const memberEntries = se_TagKeyOnly(entry);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            entries[`member.${counter}.${key}`] = value;
-        });
-        counter++;
-    }
-    return entries;
-};
-const se_TagKeyOnly = (input, context) => {
-    const entries = {};
-    if (input[_K] != null) {
-        entries[_K] = input[_K];
-    }
-    return entries;
-};
-const se_TagList = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
-        }
-        const memberEntries = se_Tag(entry);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            entries[`member.${counter}.${key}`] = value;
-        });
-        counter++;
-    }
-    return entries;
-};
-const de_AccessLog = (output, context) => {
-    const contents = {};
-    if (output[_E] != null) {
-        contents[_E] = smithyClient.parseBoolean(output[_E]);
-    }
-    if (output[_SBN] != null) {
-        contents[_SBN] = smithyClient.expectString(output[_SBN]);
-    }
-    if (output[_EI] != null) {
-        contents[_EI] = smithyClient.strictParseInt32(output[_EI]);
-    }
-    if (output[_SBP] != null) {
-        contents[_SBP] = smithyClient.expectString(output[_SBP]);
-    }
-    return contents;
-};
-const de_AccessPointNotFoundException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_AddAvailabilityZonesOutput = (output, context) => {
-    const contents = {};
-    if (String(output.AvailabilityZones).trim() === "") {
-        contents[_AZ] = [];
-    }
-    else if (output[_AZ] != null && output[_AZ][_m] != null) {
-        contents[_AZ] = de_AvailabilityZones(smithyClient.getArrayIfSingleItem(output[_AZ][_m]));
-    }
-    return contents;
-};
-const de_AdditionalAttribute = (output, context) => {
-    const contents = {};
-    if (output[_K] != null) {
-        contents[_K] = smithyClient.expectString(output[_K]);
-    }
-    if (output[_Va] != null) {
-        contents[_Va] = smithyClient.expectString(output[_Va]);
-    }
-    return contents;
-};
-const de_AdditionalAttributes = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_AdditionalAttribute(entry);
-    });
-};
-const de_AddTagsOutput = (output, context) => {
-    const contents = {};
-    return contents;
-};
-const de_AppCookieStickinessPolicies = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_AppCookieStickinessPolicy(entry);
-    });
-};
-const de_AppCookieStickinessPolicy = (output, context) => {
-    const contents = {};
-    if (output[_PN] != null) {
-        contents[_PN] = smithyClient.expectString(output[_PN]);
-    }
-    if (output[_CN] != null) {
-        contents[_CN] = smithyClient.expectString(output[_CN]);
-    }
-    return contents;
-};
-const de_ApplySecurityGroupsToLoadBalancerOutput = (output, context) => {
-    const contents = {};
-    if (String(output.SecurityGroups).trim() === "") {
-        contents[_SG] = [];
-    }
-    else if (output[_SG] != null && output[_SG][_m] != null) {
-        contents[_SG] = de_SecurityGroups(smithyClient.getArrayIfSingleItem(output[_SG][_m]));
-    }
-    return contents;
-};
-const de_AttachLoadBalancerToSubnetsOutput = (output, context) => {
-    const contents = {};
-    if (String(output.Subnets).trim() === "") {
-        contents[_S] = [];
-    }
-    else if (output[_S] != null && output[_S][_m] != null) {
-        contents[_S] = de_Subnets(smithyClient.getArrayIfSingleItem(output[_S][_m]));
-    }
-    return contents;
-};
-const de_AvailabilityZones = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return smithyClient.expectString(entry);
-    });
-};
-const de_BackendServerDescription = (output, context) => {
-    const contents = {};
-    if (output[_IPn] != null) {
-        contents[_IPn] = smithyClient.strictParseInt32(output[_IPn]);
-    }
-    if (String(output.PolicyNames).trim() === "") {
-        contents[_PNo] = [];
-    }
-    else if (output[_PNo] != null && output[_PNo][_m] != null) {
-        contents[_PNo] = de_PolicyNames(smithyClient.getArrayIfSingleItem(output[_PNo][_m]));
-    }
-    return contents;
-};
-const de_BackendServerDescriptions = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_BackendServerDescription(entry);
-    });
-};
-const de_CertificateNotFoundException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_ConfigureHealthCheckOutput = (output, context) => {
-    const contents = {};
-    if (output[_HC] != null) {
-        contents[_HC] = de_HealthCheck(output[_HC]);
-    }
-    return contents;
-};
-const de_ConnectionDraining = (output, context) => {
-    const contents = {};
-    if (output[_E] != null) {
-        contents[_E] = smithyClient.parseBoolean(output[_E]);
-    }
-    if (output[_Ti] != null) {
-        contents[_Ti] = smithyClient.strictParseInt32(output[_Ti]);
-    }
-    return contents;
-};
-const de_ConnectionSettings = (output, context) => {
-    const contents = {};
-    if (output[_IT] != null) {
-        contents[_IT] = smithyClient.strictParseInt32(output[_IT]);
-    }
-    return contents;
-};
-const de_CreateAccessPointOutput = (output, context) => {
-    const contents = {};
-    if (output[_DNSN] != null) {
-        contents[_DNSN] = smithyClient.expectString(output[_DNSN]);
-    }
-    return contents;
-};
-const de_CreateAppCookieStickinessPolicyOutput = (output, context) => {
-    const contents = {};
-    return contents;
-};
-const de_CreateLBCookieStickinessPolicyOutput = (output, context) => {
-    const contents = {};
-    return contents;
-};
-const de_CreateLoadBalancerListenerOutput = (output, context) => {
-    const contents = {};
-    return contents;
-};
-const de_CreateLoadBalancerPolicyOutput = (output, context) => {
-    const contents = {};
-    return contents;
-};
-const de_CrossZoneLoadBalancing = (output, context) => {
-    const contents = {};
-    if (output[_E] != null) {
-        contents[_E] = smithyClient.parseBoolean(output[_E]);
-    }
-    return contents;
-};
-const de_DeleteAccessPointOutput = (output, context) => {
-    const contents = {};
-    return contents;
-};
-const de_DeleteLoadBalancerListenerOutput = (output, context) => {
-    const contents = {};
-    return contents;
-};
-const de_DeleteLoadBalancerPolicyOutput = (output, context) => {
-    const contents = {};
-    return contents;
-};
-const de_DependencyThrottleException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_DeregisterEndPointsOutput = (output, context) => {
-    const contents = {};
-    if (String(output.Instances).trim() === "") {
-        contents[_I] = [];
-    }
-    else if (output[_I] != null && output[_I][_m] != null) {
-        contents[_I] = de_Instances(smithyClient.getArrayIfSingleItem(output[_I][_m]));
-    }
-    return contents;
-};
-const de_DescribeAccessPointsOutput = (output, context) => {
-    const contents = {};
-    if (String(output.LoadBalancerDescriptions).trim() === "") {
-        contents[_LBD] = [];
-    }
-    else if (output[_LBD] != null && output[_LBD][_m] != null) {
-        contents[_LBD] = de_LoadBalancerDescriptions(smithyClient.getArrayIfSingleItem(output[_LBD][_m]));
-    }
-    if (output[_NM] != null) {
-        contents[_NM] = smithyClient.expectString(output[_NM]);
-    }
-    return contents;
-};
-const de_DescribeAccountLimitsOutput = (output, context) => {
-    const contents = {};
-    if (String(output.Limits).trim() === "") {
-        contents[_Li] = [];
-    }
-    else if (output[_Li] != null && output[_Li][_m] != null) {
-        contents[_Li] = de_Limits(smithyClient.getArrayIfSingleItem(output[_Li][_m]));
-    }
-    if (output[_NM] != null) {
-        contents[_NM] = smithyClient.expectString(output[_NM]);
-    }
-    return contents;
-};
-const de_DescribeEndPointStateOutput = (output, context) => {
-    const contents = {};
-    if (String(output.InstanceStates).trim() === "") {
-        contents[_IS] = [];
-    }
-    else if (output[_IS] != null && output[_IS][_m] != null) {
-        contents[_IS] = de_InstanceStates(smithyClient.getArrayIfSingleItem(output[_IS][_m]));
-    }
-    return contents;
-};
-const de_DescribeLoadBalancerAttributesOutput = (output, context) => {
-    const contents = {};
-    if (output[_LBA] != null) {
-        contents[_LBA] = de_LoadBalancerAttributes(output[_LBA]);
-    }
-    return contents;
-};
-const de_DescribeLoadBalancerPoliciesOutput = (output, context) => {
-    const contents = {};
-    if (String(output.PolicyDescriptions).trim() === "") {
-        contents[_PD] = [];
-    }
-    else if (output[_PD] != null && output[_PD][_m] != null) {
-        contents[_PD] = de_PolicyDescriptions(smithyClient.getArrayIfSingleItem(output[_PD][_m]));
-    }
-    return contents;
-};
-const de_DescribeLoadBalancerPolicyTypesOutput = (output, context) => {
-    const contents = {};
-    if (String(output.PolicyTypeDescriptions).trim() === "") {
-        contents[_PTD] = [];
-    }
-    else if (output[_PTD] != null && output[_PTD][_m] != null) {
-        contents[_PTD] = de_PolicyTypeDescriptions(smithyClient.getArrayIfSingleItem(output[_PTD][_m]));
-    }
-    return contents;
-};
-const de_DescribeTagsOutput = (output, context) => {
-    const contents = {};
-    if (String(output.TagDescriptions).trim() === "") {
-        contents[_TD] = [];
-    }
-    else if (output[_TD] != null && output[_TD][_m] != null) {
-        contents[_TD] = de_TagDescriptions(smithyClient.getArrayIfSingleItem(output[_TD][_m]));
-    }
-    return contents;
-};
-const de_DetachLoadBalancerFromSubnetsOutput = (output, context) => {
-    const contents = {};
-    if (String(output.Subnets).trim() === "") {
-        contents[_S] = [];
-    }
-    else if (output[_S] != null && output[_S][_m] != null) {
-        contents[_S] = de_Subnets(smithyClient.getArrayIfSingleItem(output[_S][_m]));
-    }
-    return contents;
-};
-const de_DuplicateAccessPointNameException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_DuplicateListenerException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_DuplicatePolicyNameException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_DuplicateTagKeysException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_HealthCheck = (output, context) => {
-    const contents = {};
-    if (output[_Ta] != null) {
-        contents[_Ta] = smithyClient.expectString(output[_Ta]);
-    }
-    if (output[_In] != null) {
-        contents[_In] = smithyClient.strictParseInt32(output[_In]);
-    }
-    if (output[_Ti] != null) {
-        contents[_Ti] = smithyClient.strictParseInt32(output[_Ti]);
-    }
-    if (output[_UT] != null) {
-        contents[_UT] = smithyClient.strictParseInt32(output[_UT]);
-    }
-    if (output[_HT] != null) {
-        contents[_HT] = smithyClient.strictParseInt32(output[_HT]);
-    }
-    return contents;
-};
-const de_Instance = (output, context) => {
-    const contents = {};
-    if (output[_II] != null) {
-        contents[_II] = smithyClient.expectString(output[_II]);
-    }
-    return contents;
-};
-const de_Instances = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Instance(entry);
-    });
-};
-const de_InstanceState = (output, context) => {
-    const contents = {};
-    if (output[_II] != null) {
-        contents[_II] = smithyClient.expectString(output[_II]);
-    }
-    if (output[_St] != null) {
-        contents[_St] = smithyClient.expectString(output[_St]);
-    }
-    if (output[_RC] != null) {
-        contents[_RC] = smithyClient.expectString(output[_RC]);
-    }
-    if (output[_D] != null) {
-        contents[_D] = smithyClient.expectString(output[_D]);
-    }
-    return contents;
-};
-const de_InstanceStates = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_InstanceState(entry);
-    });
-};
-const de_InvalidConfigurationRequestException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_InvalidEndPointException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_InvalidSchemeException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_InvalidSecurityGroupException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_InvalidSubnetException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_LBCookieStickinessPolicies = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_LBCookieStickinessPolicy(entry);
-    });
-};
-const de_LBCookieStickinessPolicy = (output, context) => {
-    const contents = {};
-    if (output[_PN] != null) {
-        contents[_PN] = smithyClient.expectString(output[_PN]);
-    }
-    if (output[_CEP] != null) {
-        contents[_CEP] = smithyClient.strictParseLong(output[_CEP]);
-    }
-    return contents;
-};
-const de_Limit = (output, context) => {
-    const contents = {};
-    if (output[_N] != null) {
-        contents[_N] = smithyClient.expectString(output[_N]);
-    }
-    if (output[_Ma] != null) {
-        contents[_Ma] = smithyClient.expectString(output[_Ma]);
-    }
-    return contents;
-};
-const de_Limits = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Limit(entry);
-    });
-};
-const de_Listener = (output, context) => {
-    const contents = {};
-    if (output[_P] != null) {
-        contents[_P] = smithyClient.expectString(output[_P]);
-    }
-    if (output[_LBPo] != null) {
-        contents[_LBPo] = smithyClient.strictParseInt32(output[_LBPo]);
-    }
-    if (output[_IP] != null) {
-        contents[_IP] = smithyClient.expectString(output[_IP]);
-    }
-    if (output[_IPn] != null) {
-        contents[_IPn] = smithyClient.strictParseInt32(output[_IPn]);
-    }
-    if (output[_SSLCI] != null) {
-        contents[_SSLCI] = smithyClient.expectString(output[_SSLCI]);
-    }
-    return contents;
-};
-const de_ListenerDescription = (output, context) => {
-    const contents = {};
-    if (output[_Lis] != null) {
-        contents[_Lis] = de_Listener(output[_Lis]);
-    }
-    if (String(output.PolicyNames).trim() === "") {
-        contents[_PNo] = [];
-    }
-    else if (output[_PNo] != null && output[_PNo][_m] != null) {
-        contents[_PNo] = de_PolicyNames(smithyClient.getArrayIfSingleItem(output[_PNo][_m]));
-    }
-    return contents;
-};
-const de_ListenerDescriptions = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ListenerDescription(entry);
-    });
-};
-const de_ListenerNotFoundException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_LoadBalancerAttributeNotFoundException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_LoadBalancerAttributes = (output, context) => {
-    const contents = {};
-    if (output[_CZLB] != null) {
-        contents[_CZLB] = de_CrossZoneLoadBalancing(output[_CZLB]);
-    }
-    if (output[_AL] != null) {
-        contents[_AL] = de_AccessLog(output[_AL]);
-    }
-    if (output[_CD] != null) {
-        contents[_CD] = de_ConnectionDraining(output[_CD]);
-    }
-    if (output[_CS] != null) {
-        contents[_CS] = de_ConnectionSettings(output[_CS]);
-    }
-    if (String(output.AdditionalAttributes).trim() === "") {
-        contents[_AA] = [];
-    }
-    else if (output[_AA] != null && output[_AA][_m] != null) {
-        contents[_AA] = de_AdditionalAttributes(smithyClient.getArrayIfSingleItem(output[_AA][_m]));
-    }
-    return contents;
-};
-const de_LoadBalancerDescription = (output, context) => {
-    const contents = {};
-    if (output[_LBN] != null) {
-        contents[_LBN] = smithyClient.expectString(output[_LBN]);
-    }
-    if (output[_DNSN] != null) {
-        contents[_DNSN] = smithyClient.expectString(output[_DNSN]);
-    }
-    if (output[_CHZN] != null) {
-        contents[_CHZN] = smithyClient.expectString(output[_CHZN]);
-    }
-    if (output[_CHZNID] != null) {
-        contents[_CHZNID] = smithyClient.expectString(output[_CHZNID]);
-    }
-    if (String(output.ListenerDescriptions).trim() === "") {
-        contents[_LD] = [];
-    }
-    else if (output[_LD] != null && output[_LD][_m] != null) {
-        contents[_LD] = de_ListenerDescriptions(smithyClient.getArrayIfSingleItem(output[_LD][_m]));
-    }
-    if (output[_Po] != null) {
-        contents[_Po] = de_Policies(output[_Po]);
-    }
-    if (String(output.BackendServerDescriptions).trim() === "") {
-        contents[_BSD] = [];
-    }
-    else if (output[_BSD] != null && output[_BSD][_m] != null) {
-        contents[_BSD] = de_BackendServerDescriptions(smithyClient.getArrayIfSingleItem(output[_BSD][_m]));
-    }
-    if (String(output.AvailabilityZones).trim() === "") {
-        contents[_AZ] = [];
-    }
-    else if (output[_AZ] != null && output[_AZ][_m] != null) {
-        contents[_AZ] = de_AvailabilityZones(smithyClient.getArrayIfSingleItem(output[_AZ][_m]));
-    }
-    if (String(output.Subnets).trim() === "") {
-        contents[_S] = [];
-    }
-    else if (output[_S] != null && output[_S][_m] != null) {
-        contents[_S] = de_Subnets(smithyClient.getArrayIfSingleItem(output[_S][_m]));
-    }
-    if (output[_VPCI] != null) {
-        contents[_VPCI] = smithyClient.expectString(output[_VPCI]);
-    }
-    if (String(output.Instances).trim() === "") {
-        contents[_I] = [];
-    }
-    else if (output[_I] != null && output[_I][_m] != null) {
-        contents[_I] = de_Instances(smithyClient.getArrayIfSingleItem(output[_I][_m]));
-    }
-    if (output[_HC] != null) {
-        contents[_HC] = de_HealthCheck(output[_HC]);
-    }
-    if (output[_SSG] != null) {
-        contents[_SSG] = de_SourceSecurityGroup(output[_SSG]);
-    }
-    if (String(output.SecurityGroups).trim() === "") {
-        contents[_SG] = [];
-    }
-    else if (output[_SG] != null && output[_SG][_m] != null) {
-        contents[_SG] = de_SecurityGroups(smithyClient.getArrayIfSingleItem(output[_SG][_m]));
-    }
-    if (output[_CT] != null) {
-        contents[_CT] = smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(output[_CT]));
-    }
-    if (output[_Sc] != null) {
-        contents[_Sc] = smithyClient.expectString(output[_Sc]);
-    }
-    return contents;
-};
-const de_LoadBalancerDescriptions = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_LoadBalancerDescription(entry);
-    });
-};
-const de_ModifyLoadBalancerAttributesOutput = (output, context) => {
-    const contents = {};
-    if (output[_LBN] != null) {
-        contents[_LBN] = smithyClient.expectString(output[_LBN]);
-    }
-    if (output[_LBA] != null) {
-        contents[_LBA] = de_LoadBalancerAttributes(output[_LBA]);
-    }
-    return contents;
-};
-const de_OperationNotPermittedException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_Policies = (output, context) => {
-    const contents = {};
-    if (String(output.AppCookieStickinessPolicies).trim() === "") {
-        contents[_ACSP] = [];
-    }
-    else if (output[_ACSP] != null && output[_ACSP][_m] != null) {
-        contents[_ACSP] = de_AppCookieStickinessPolicies(smithyClient.getArrayIfSingleItem(output[_ACSP][_m]));
-    }
-    if (String(output.LBCookieStickinessPolicies).trim() === "") {
-        contents[_LBCSP] = [];
-    }
-    else if (output[_LBCSP] != null && output[_LBCSP][_m] != null) {
-        contents[_LBCSP] = de_LBCookieStickinessPolicies(smithyClient.getArrayIfSingleItem(output[_LBCSP][_m]));
-    }
-    if (String(output.OtherPolicies).trim() === "") {
-        contents[_OP] = [];
-    }
-    else if (output[_OP] != null && output[_OP][_m] != null) {
-        contents[_OP] = de_PolicyNames(smithyClient.getArrayIfSingleItem(output[_OP][_m]));
-    }
-    return contents;
-};
-const de_PolicyAttributeDescription = (output, context) => {
-    const contents = {};
-    if (output[_AN] != null) {
-        contents[_AN] = smithyClient.expectString(output[_AN]);
-    }
-    if (output[_AV] != null) {
-        contents[_AV] = smithyClient.expectString(output[_AV]);
-    }
-    return contents;
-};
-const de_PolicyAttributeDescriptions = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_PolicyAttributeDescription(entry);
-    });
-};
-const de_PolicyAttributeTypeDescription = (output, context) => {
-    const contents = {};
-    if (output[_AN] != null) {
-        contents[_AN] = smithyClient.expectString(output[_AN]);
-    }
-    if (output[_ATt] != null) {
-        contents[_ATt] = smithyClient.expectString(output[_ATt]);
-    }
-    if (output[_D] != null) {
-        contents[_D] = smithyClient.expectString(output[_D]);
-    }
-    if (output[_DV] != null) {
-        contents[_DV] = smithyClient.expectString(output[_DV]);
-    }
-    if (output[_C] != null) {
-        contents[_C] = smithyClient.expectString(output[_C]);
-    }
-    return contents;
-};
-const de_PolicyAttributeTypeDescriptions = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_PolicyAttributeTypeDescription(entry);
-    });
-};
-const de_PolicyDescription = (output, context) => {
-    const contents = {};
-    if (output[_PN] != null) {
-        contents[_PN] = smithyClient.expectString(output[_PN]);
-    }
-    if (output[_PTN] != null) {
-        contents[_PTN] = smithyClient.expectString(output[_PTN]);
-    }
-    if (String(output.PolicyAttributeDescriptions).trim() === "") {
-        contents[_PAD] = [];
-    }
-    else if (output[_PAD] != null && output[_PAD][_m] != null) {
-        contents[_PAD] = de_PolicyAttributeDescriptions(smithyClient.getArrayIfSingleItem(output[_PAD][_m]));
-    }
-    return contents;
-};
-const de_PolicyDescriptions = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_PolicyDescription(entry);
-    });
-};
-const de_PolicyNames = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return smithyClient.expectString(entry);
-    });
-};
-const de_PolicyNotFoundException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_PolicyTypeDescription = (output, context) => {
-    const contents = {};
-    if (output[_PTN] != null) {
-        contents[_PTN] = smithyClient.expectString(output[_PTN]);
-    }
-    if (output[_D] != null) {
-        contents[_D] = smithyClient.expectString(output[_D]);
-    }
-    if (String(output.PolicyAttributeTypeDescriptions).trim() === "") {
-        contents[_PATD] = [];
-    }
-    else if (output[_PATD] != null && output[_PATD][_m] != null) {
-        contents[_PATD] = de_PolicyAttributeTypeDescriptions(smithyClient.getArrayIfSingleItem(output[_PATD][_m]));
-    }
-    return contents;
-};
-const de_PolicyTypeDescriptions = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_PolicyTypeDescription(entry);
-    });
-};
-const de_PolicyTypeNotFoundException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_RegisterEndPointsOutput = (output, context) => {
-    const contents = {};
-    if (String(output.Instances).trim() === "") {
-        contents[_I] = [];
-    }
-    else if (output[_I] != null && output[_I][_m] != null) {
-        contents[_I] = de_Instances(smithyClient.getArrayIfSingleItem(output[_I][_m]));
-    }
-    return contents;
-};
-const de_RemoveAvailabilityZonesOutput = (output, context) => {
-    const contents = {};
-    if (String(output.AvailabilityZones).trim() === "") {
-        contents[_AZ] = [];
-    }
-    else if (output[_AZ] != null && output[_AZ][_m] != null) {
-        contents[_AZ] = de_AvailabilityZones(smithyClient.getArrayIfSingleItem(output[_AZ][_m]));
-    }
-    return contents;
-};
-const de_RemoveTagsOutput = (output, context) => {
-    const contents = {};
-    return contents;
-};
-const de_SecurityGroups = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return smithyClient.expectString(entry);
-    });
-};
-const de_SetLoadBalancerListenerSSLCertificateOutput = (output, context) => {
-    const contents = {};
-    return contents;
-};
-const de_SetLoadBalancerPoliciesForBackendServerOutput = (output, context) => {
-    const contents = {};
-    return contents;
-};
-const de_SetLoadBalancerPoliciesOfListenerOutput = (output, context) => {
-    const contents = {};
-    return contents;
-};
-const de_SourceSecurityGroup = (output, context) => {
-    const contents = {};
-    if (output[_OA] != null) {
-        contents[_OA] = smithyClient.expectString(output[_OA]);
-    }
-    if (output[_GN] != null) {
-        contents[_GN] = smithyClient.expectString(output[_GN]);
-    }
-    return contents;
-};
-const de_SubnetNotFoundException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_Subnets = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return smithyClient.expectString(entry);
-    });
-};
-const de_Tag = (output, context) => {
-    const contents = {};
-    if (output[_K] != null) {
-        contents[_K] = smithyClient.expectString(output[_K]);
-    }
-    if (output[_Va] != null) {
-        contents[_Va] = smithyClient.expectString(output[_Va]);
-    }
-    return contents;
-};
-const de_TagDescription = (output, context) => {
-    const contents = {};
-    if (output[_LBN] != null) {
-        contents[_LBN] = smithyClient.expectString(output[_LBN]);
-    }
-    if (String(output.Tags).trim() === "") {
-        contents[_T] = [];
-    }
-    else if (output[_T] != null && output[_T][_m] != null) {
-        contents[_T] = de_TagList(smithyClient.getArrayIfSingleItem(output[_T][_m]));
-    }
-    return contents;
-};
-const de_TagDescriptions = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_TagDescription(entry);
-    });
-};
-const de_TagList = (output, context) => {
-    return (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Tag(entry);
-    });
-};
-const de_TooManyAccessPointsException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_TooManyPoliciesException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_TooManyTagsException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const de_UnsupportedProtocolException = (output, context) => {
-    const contents = {};
-    if (output[_Me] != null) {
-        contents[_Me] = smithyClient.expectString(output[_Me]);
-    }
-    return contents;
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
-const throwDefaultError = smithyClient.withBaseException(ElasticLoadBalancingServiceException);
-const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const contents = {
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-        headers,
-    };
-    if (body !== undefined) {
-        contents.body = body;
-    }
-    return new protocolHttp.HttpRequest(contents);
-};
-const SHARED_HEADERS = {
-    "content-type": "application/x-www-form-urlencoded",
-};
-const _ = "2012-06-01";
-const _A = "Action";
-const _AA = "AdditionalAttributes";
-const _ACSP = "AppCookieStickinessPolicies";
+
+const _AA = "AdditionalAttribute";
+const _AAZI = "AddAvailabilityZonesInput";
+const _AAZO = "AddAvailabilityZonesOutput";
+const _AAd = "AdditionalAttributes";
+const _ACSP = "AppCookieStickinessPolicy";
+const _ACSPp = "AppCookieStickinessPolicies";
 const _AL = "AccessLog";
 const _ALBTS = "AttachLoadBalancerToSubnets";
+const _ALBTSI = "AttachLoadBalancerToSubnetsInput";
+const _ALBTSO = "AttachLoadBalancerToSubnetsOutput";
 const _AN = "AttributeName";
+const _APNFE = "AccessPointNotFoundException";
 const _ASGTLB = "ApplySecurityGroupsToLoadBalancer";
-const _AT = "AddTags";
-const _ATt = "AttributeType";
+const _ASGTLBI = "ApplySecurityGroupsToLoadBalancerInput";
+const _ASGTLBO = "ApplySecurityGroupsToLoadBalancerOutput";
+const _AT = "AttributeType";
+const _ATI = "AddTagsInput";
+const _ATO = "AddTagsOutput";
+const _ATd = "AddTags";
 const _AV = "AttributeValue";
 const _AZ = "AvailabilityZones";
-const _BSD = "BackendServerDescriptions";
+const _BSD = "BackendServerDescription";
+const _BSDa = "BackendServerDescriptions";
 const _C = "Cardinality";
 const _CACSP = "CreateAppCookieStickinessPolicy";
+const _CACSPI = "CreateAppCookieStickinessPolicyInput";
+const _CACSPO = "CreateAppCookieStickinessPolicyOutput";
+const _CAPI = "CreateAccessPointInput";
+const _CAPO = "CreateAccessPointOutput";
 const _CD = "ConnectionDraining";
 const _CEP = "CookieExpirationPeriod";
 const _CHC = "ConfigureHealthCheck";
+const _CHCI = "ConfigureHealthCheckInput";
+const _CHCO = "ConfigureHealthCheckOutput";
 const _CHZN = "CanonicalHostedZoneName";
 const _CHZNID = "CanonicalHostedZoneNameID";
 const _CLB = "CreateLoadBalancer";
 const _CLBCSP = "CreateLBCookieStickinessPolicy";
+const _CLBCSPI = "CreateLBCookieStickinessPolicyInput";
+const _CLBCSPO = "CreateLBCookieStickinessPolicyOutput";
 const _CLBL = "CreateLoadBalancerListeners";
+const _CLBLI = "CreateLoadBalancerListenerInput";
+const _CLBLO = "CreateLoadBalancerListenerOutput";
 const _CLBP = "CreateLoadBalancerPolicy";
+const _CLBPI = "CreateLoadBalancerPolicyInput";
+const _CLBPO = "CreateLoadBalancerPolicyOutput";
 const _CN = "CookieName";
+const _CNFE = "CertificateNotFoundException";
 const _CS = "ConnectionSettings";
 const _CT = "CreatedTime";
 const _CZLB = "CrossZoneLoadBalancing";
 const _D = "Description";
 const _DAL = "DescribeAccountLimits";
+const _DALI = "DescribeAccountLimitsInput";
+const _DALO = "DescribeAccountLimitsOutput";
+const _DAPI = "DeleteAccessPointInput";
+const _DAPIe = "DescribeAccessPointsInput";
+const _DAPNE = "DuplicateAccessPointNameException";
+const _DAPO = "DeleteAccessPointOutput";
+const _DAPOe = "DescribeAccessPointsOutput";
 const _DAZFLB = "DisableAvailabilityZonesForLoadBalancer";
+const _DEPI = "DeregisterEndPointsInput";
+const _DEPO = "DeregisterEndPointsOutput";
+const _DEPSI = "DescribeEndPointStateInput";
+const _DEPSO = "DescribeEndPointStateOutput";
 const _DIFLB = "DeregisterInstancesFromLoadBalancer";
 const _DIH = "DescribeInstanceHealth";
 const _DLB = "DeleteLoadBalancer";
 const _DLBA = "DescribeLoadBalancerAttributes";
+const _DLBAI = "DescribeLoadBalancerAttributesInput";
+const _DLBAO = "DescribeLoadBalancerAttributesOutput";
 const _DLBFS = "DetachLoadBalancerFromSubnets";
+const _DLBFSI = "DetachLoadBalancerFromSubnetsInput";
+const _DLBFSO = "DetachLoadBalancerFromSubnetsOutput";
 const _DLBL = "DeleteLoadBalancerListeners";
+const _DLBLI = "DeleteLoadBalancerListenerInput";
+const _DLBLO = "DeleteLoadBalancerListenerOutput";
 const _DLBP = "DeleteLoadBalancerPolicy";
+const _DLBPI = "DeleteLoadBalancerPolicyInput";
+const _DLBPIe = "DescribeLoadBalancerPoliciesInput";
+const _DLBPO = "DeleteLoadBalancerPolicyOutput";
+const _DLBPOe = "DescribeLoadBalancerPoliciesOutput";
 const _DLBPT = "DescribeLoadBalancerPolicyTypes";
+const _DLBPTI = "DescribeLoadBalancerPolicyTypesInput";
+const _DLBPTO = "DescribeLoadBalancerPolicyTypesOutput";
 const _DLBPe = "DescribeLoadBalancerPolicies";
 const _DLBe = "DescribeLoadBalancers";
+const _DLE = "DuplicateListenerException";
 const _DNSN = "DNSName";
+const _DPNE = "DuplicatePolicyNameException";
 const _DT = "DescribeTags";
+const _DTE = "DependencyThrottleException";
+const _DTI = "DescribeTagsInput";
+const _DTKE = "DuplicateTagKeysException";
+const _DTO = "DescribeTagsOutput";
 const _DV = "DefaultValue";
 const _E = "Enabled";
 const _EAZFLB = "EnableAvailabilityZonesForLoadBalancer";
@@ -3184,93 +530,904 @@ const _GN = "GroupName";
 const _HC = "HealthCheck";
 const _HT = "HealthyThreshold";
 const _I = "Instances";
+const _ICRE = "InvalidConfigurationRequestException";
+const _IEPE = "InvalidEndPointException";
 const _II = "InstanceId";
-const _IP = "InstanceProtocol";
-const _IPn = "InstancePort";
+const _IP = "InstancePort";
+const _IPn = "InstanceProtocol";
 const _IS = "InstanceStates";
+const _ISE = "InvalidSchemeException";
+const _ISEn = "InvalidSubnetException";
+const _ISGE = "InvalidSecurityGroupException";
+const _ISn = "InstanceState";
 const _IT = "IdleTimeout";
 const _In = "Interval";
+const _Ins = "Instance";
 const _K = "Key";
 const _L = "Listeners";
 const _LBA = "LoadBalancerAttributes";
-const _LBCSP = "LBCookieStickinessPolicies";
+const _LBANFE = "LoadBalancerAttributeNotFoundException";
+const _LBCSP = "LBCookieStickinessPolicy";
+const _LBCSPo = "LBCookieStickinessPolicies";
 const _LBD = "LoadBalancerDescriptions";
+const _LBDo = "LoadBalancerDescription";
 const _LBN = "LoadBalancerName";
 const _LBNo = "LoadBalancerNames";
 const _LBP = "LoadBalancerPorts";
 const _LBPo = "LoadBalancerPort";
-const _LD = "ListenerDescriptions";
+const _LD = "ListenerDescription";
+const _LDi = "ListenerDescriptions";
+const _LNFE = "ListenerNotFoundException";
 const _Li = "Limits";
+const _Lim = "Limit";
 const _Lis = "Listener";
-const _M = "Marker";
+const _M = "Message";
 const _MLBA = "ModifyLoadBalancerAttributes";
-const _Ma = "Max";
-const _Me = "Message";
+const _MLBAI = "ModifyLoadBalancerAttributesInput";
+const _MLBAO = "ModifyLoadBalancerAttributesOutput";
+const _Ma = "Marker";
+const _Max = "Max";
 const _N = "Name";
 const _NM = "NextMarker";
 const _OA = "OwnerAlias";
+const _ONPE = "OperationNotPermittedException";
 const _OP = "OtherPolicies";
 const _P = "Protocol";
 const _PA = "PolicyAttributes";
-const _PAD = "PolicyAttributeDescriptions";
-const _PATD = "PolicyAttributeTypeDescriptions";
+const _PAD = "PolicyAttributeDescription";
+const _PADo = "PolicyAttributeDescriptions";
+const _PATD = "PolicyAttributeTypeDescription";
+const _PATDo = "PolicyAttributeTypeDescriptions";
+const _PAo = "PolicyAttribute";
 const _PD = "PolicyDescriptions";
+const _PDo = "PolicyDescription";
 const _PN = "PolicyName";
+const _PNFE = "PolicyNotFoundException";
 const _PNo = "PolicyNames";
 const _PS = "PageSize";
 const _PTD = "PolicyTypeDescriptions";
+const _PTDo = "PolicyTypeDescription";
 const _PTN = "PolicyTypeName";
+const _PTNFE = "PolicyTypeNotFoundException";
 const _PTNo = "PolicyTypeNames";
 const _Po = "Policies";
+const _RAZI = "RemoveAvailabilityZonesInput";
+const _RAZO = "RemoveAvailabilityZonesOutput";
 const _RC = "ReasonCode";
+const _REPI = "RegisterEndPointsInput";
+const _REPO = "RegisterEndPointsOutput";
 const _RIWLB = "RegisterInstancesWithLoadBalancer";
 const _RT = "RemoveTags";
+const _RTI = "RemoveTagsInput";
+const _RTO = "RemoveTagsOutput";
 const _S = "Subnets";
 const _SBN = "S3BucketName";
 const _SBP = "S3BucketPrefix";
 const _SG = "SecurityGroups";
 const _SLBLSSLC = "SetLoadBalancerListenerSSLCertificate";
+const _SLBLSSLCI = "SetLoadBalancerListenerSSLCertificateInput";
+const _SLBLSSLCO = "SetLoadBalancerListenerSSLCertificateOutput";
 const _SLBPFBS = "SetLoadBalancerPoliciesForBackendServer";
+const _SLBPFBSI = "SetLoadBalancerPoliciesForBackendServerInput";
+const _SLBPFBSO = "SetLoadBalancerPoliciesForBackendServerOutput";
 const _SLBPOL = "SetLoadBalancerPoliciesOfListener";
+const _SLBPOLI = "SetLoadBalancerPoliciesOfListenerInput";
+const _SLBPOLO = "SetLoadBalancerPoliciesOfListenerOutput";
+const _SNFE = "SubnetNotFoundException";
 const _SSG = "SourceSecurityGroup";
 const _SSLCI = "SSLCertificateId";
 const _Sc = "Scheme";
 const _St = "State";
 const _T = "Tags";
 const _TD = "TagDescriptions";
+const _TDa = "TagDescription";
+const _TKL = "TagKeyList";
+const _TKO = "TagKeyOnly";
+const _TL = "TagList";
+const _TMAPE = "TooManyAccessPointsException";
+const _TMPE = "TooManyPoliciesException";
+const _TMTE = "TooManyTagsException";
 const _Ta = "Target";
+const _Tag = "Tag";
 const _Ti = "Timeout";
+const _UPE = "UnsupportedProtocolException";
 const _UT = "UnhealthyThreshold";
-const _V = "Version";
+const _V = "Value";
 const _VPCI = "VPCId";
-const _Va = "Value";
-const _m = "member";
-const buildFormUrlencodedString = (formEntries) => Object.entries(formEntries)
-    .map(([key, value]) => smithyClient.extendedEncodeURIComponent(key) + "=" + smithyClient.extendedEncodeURIComponent(value))
-    .join("&");
-const loadQueryErrorCode = (output, data) => {
-    if (data.Error?.Code !== undefined) {
-        return data.Error.Code;
-    }
-    if (output.statusCode == 404) {
-        return "NotFound";
-    }
-};
+const _aQE = "awsQueryError";
+const _c = "client";
+const _e = "error";
+const _hE = "httpError";
+const _s = "smithy.ts.sdk.synthetic.com.amazonaws.elasticloadbalancing";
+const n0 = "com.amazonaws.elasticloadbalancing";
+var AccessLog = [3, n0, _AL, 0, [_E, _SBN, _EI, _SBP], [2, 0, 1, 0]];
+var AccessPointNotFoundException = [
+    -3,
+    n0,
+    _APNFE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`LoadBalancerNotFound`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessPointNotFoundException, AccessPointNotFoundException$1);
+var AddAvailabilityZonesInput = [3, n0, _AAZI, 0, [_LBN, _AZ], [0, 64 | 0]];
+var AddAvailabilityZonesOutput = [3, n0, _AAZO, 0, [_AZ], [64 | 0]];
+var AdditionalAttribute = [3, n0, _AA, 0, [_K, _V], [0, 0]];
+var AddTagsInput = [3, n0, _ATI, 0, [_LBNo, _T], [64 | 0, () => TagList]];
+var AddTagsOutput = [3, n0, _ATO, 0, [], []];
+var AppCookieStickinessPolicy = [3, n0, _ACSP, 0, [_PN, _CN], [0, 0]];
+var ApplySecurityGroupsToLoadBalancerInput = [
+    3,
+    n0,
+    _ASGTLBI,
+    0,
+    [_LBN, _SG],
+    [0, 64 | 0],
+];
+var ApplySecurityGroupsToLoadBalancerOutput = [3, n0, _ASGTLBO, 0, [_SG], [64 | 0]];
+var AttachLoadBalancerToSubnetsInput = [3, n0, _ALBTSI, 0, [_LBN, _S], [0, 64 | 0]];
+var AttachLoadBalancerToSubnetsOutput = [3, n0, _ALBTSO, 0, [_S], [64 | 0]];
+var BackendServerDescription = [3, n0, _BSD, 0, [_IP, _PNo], [1, 64 | 0]];
+var CertificateNotFoundException = [
+    -3,
+    n0,
+    _CNFE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`CertificateNotFound`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(CertificateNotFoundException, CertificateNotFoundException$1);
+var ConfigureHealthCheckInput = [3, n0, _CHCI, 0, [_LBN, _HC], [0, () => HealthCheck]];
+var ConfigureHealthCheckOutput = [3, n0, _CHCO, 0, [_HC], [() => HealthCheck]];
+var ConnectionDraining = [3, n0, _CD, 0, [_E, _Ti], [2, 1]];
+var ConnectionSettings = [3, n0, _CS, 0, [_IT], [1]];
+var CreateAccessPointInput = [
+    3,
+    n0,
+    _CAPI,
+    0,
+    [_LBN, _L, _AZ, _S, _SG, _Sc, _T],
+    [0, () => Listeners, 64 | 0, 64 | 0, 64 | 0, 0, () => TagList],
+];
+var CreateAccessPointOutput = [3, n0, _CAPO, 0, [_DNSN], [0]];
+var CreateAppCookieStickinessPolicyInput = [
+    3,
+    n0,
+    _CACSPI,
+    0,
+    [_LBN, _PN, _CN],
+    [0, 0, 0],
+];
+var CreateAppCookieStickinessPolicyOutput = [3, n0, _CACSPO, 0, [], []];
+var CreateLBCookieStickinessPolicyInput = [
+    3,
+    n0,
+    _CLBCSPI,
+    0,
+    [_LBN, _PN, _CEP],
+    [0, 0, 1],
+];
+var CreateLBCookieStickinessPolicyOutput = [3, n0, _CLBCSPO, 0, [], []];
+var CreateLoadBalancerListenerInput = [
+    3,
+    n0,
+    _CLBLI,
+    0,
+    [_LBN, _L],
+    [0, () => Listeners],
+];
+var CreateLoadBalancerListenerOutput = [3, n0, _CLBLO, 0, [], []];
+var CreateLoadBalancerPolicyInput = [
+    3,
+    n0,
+    _CLBPI,
+    0,
+    [_LBN, _PN, _PTN, _PA],
+    [0, 0, 0, () => PolicyAttributes],
+];
+var CreateLoadBalancerPolicyOutput = [3, n0, _CLBPO, 0, [], []];
+var CrossZoneLoadBalancing = [3, n0, _CZLB, 0, [_E], [2]];
+var DeleteAccessPointInput = [3, n0, _DAPI, 0, [_LBN], [0]];
+var DeleteAccessPointOutput = [3, n0, _DAPO, 0, [], []];
+var DeleteLoadBalancerListenerInput = [3, n0, _DLBLI, 0, [_LBN, _LBP], [0, 64 | 1]];
+var DeleteLoadBalancerListenerOutput = [3, n0, _DLBLO, 0, [], []];
+var DeleteLoadBalancerPolicyInput = [3, n0, _DLBPI, 0, [_LBN, _PN], [0, 0]];
+var DeleteLoadBalancerPolicyOutput = [3, n0, _DLBPO, 0, [], []];
+var DependencyThrottleException = [
+    -3,
+    n0,
+    _DTE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`DependencyThrottle`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(DependencyThrottleException, DependencyThrottleException$1);
+var DeregisterEndPointsInput = [3, n0, _DEPI, 0, [_LBN, _I], [0, () => Instances]];
+var DeregisterEndPointsOutput = [3, n0, _DEPO, 0, [_I], [() => Instances]];
+var DescribeAccessPointsInput = [3, n0, _DAPIe, 0, [_LBNo, _Ma, _PS], [64 | 0, 0, 1]];
+var DescribeAccessPointsOutput = [
+    3,
+    n0,
+    _DAPOe,
+    0,
+    [_LBD, _NM],
+    [() => LoadBalancerDescriptions, 0],
+];
+var DescribeAccountLimitsInput = [3, n0, _DALI, 0, [_Ma, _PS], [0, 1]];
+var DescribeAccountLimitsOutput = [3, n0, _DALO, 0, [_Li, _NM], [() => Limits, 0]];
+var DescribeEndPointStateInput = [3, n0, _DEPSI, 0, [_LBN, _I], [0, () => Instances]];
+var DescribeEndPointStateOutput = [3, n0, _DEPSO, 0, [_IS], [() => InstanceStates]];
+var DescribeLoadBalancerAttributesInput = [3, n0, _DLBAI, 0, [_LBN], [0]];
+var DescribeLoadBalancerAttributesOutput = [
+    3,
+    n0,
+    _DLBAO,
+    0,
+    [_LBA],
+    [() => LoadBalancerAttributes],
+];
+var DescribeLoadBalancerPoliciesInput = [3, n0, _DLBPIe, 0, [_LBN, _PNo], [0, 64 | 0]];
+var DescribeLoadBalancerPoliciesOutput = [
+    3,
+    n0,
+    _DLBPOe,
+    0,
+    [_PD],
+    [() => PolicyDescriptions],
+];
+var DescribeLoadBalancerPolicyTypesInput = [3, n0, _DLBPTI, 0, [_PTNo], [64 | 0]];
+var DescribeLoadBalancerPolicyTypesOutput = [
+    3,
+    n0,
+    _DLBPTO,
+    0,
+    [_PTD],
+    [() => PolicyTypeDescriptions],
+];
+var DescribeTagsInput = [3, n0, _DTI, 0, [_LBNo], [64 | 0]];
+var DescribeTagsOutput = [3, n0, _DTO, 0, [_TD], [() => TagDescriptions]];
+var DetachLoadBalancerFromSubnetsInput = [3, n0, _DLBFSI, 0, [_LBN, _S], [0, 64 | 0]];
+var DetachLoadBalancerFromSubnetsOutput = [3, n0, _DLBFSO, 0, [_S], [64 | 0]];
+var DuplicateAccessPointNameException = [
+    -3,
+    n0,
+    _DAPNE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`DuplicateLoadBalancerName`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(DuplicateAccessPointNameException, DuplicateAccessPointNameException$1);
+var DuplicateListenerException = [
+    -3,
+    n0,
+    _DLE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`DuplicateListener`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(DuplicateListenerException, DuplicateListenerException$1);
+var DuplicatePolicyNameException = [
+    -3,
+    n0,
+    _DPNE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`DuplicatePolicyName`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(DuplicatePolicyNameException, DuplicatePolicyNameException$1);
+var DuplicateTagKeysException = [
+    -3,
+    n0,
+    _DTKE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`DuplicateTagKeys`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(DuplicateTagKeysException, DuplicateTagKeysException$1);
+var HealthCheck = [3, n0, _HC, 0, [_Ta, _In, _Ti, _UT, _HT], [0, 1, 1, 1, 1]];
+var Instance = [3, n0, _Ins, 0, [_II], [0]];
+var InstanceState = [3, n0, _ISn, 0, [_II, _St, _RC, _D], [0, 0, 0, 0]];
+var InvalidConfigurationRequestException = [
+    -3,
+    n0,
+    _ICRE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+        [_aQE]: [`InvalidConfigurationRequest`, 409],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidConfigurationRequestException, InvalidConfigurationRequestException$1);
+var InvalidEndPointException = [
+    -3,
+    n0,
+    _IEPE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`InvalidInstance`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidEndPointException, InvalidEndPointException$1);
+var InvalidSchemeException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`InvalidScheme`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidSchemeException, InvalidSchemeException$1);
+var InvalidSecurityGroupException = [
+    -3,
+    n0,
+    _ISGE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`InvalidSecurityGroup`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidSecurityGroupException, InvalidSecurityGroupException$1);
+var InvalidSubnetException = [
+    -3,
+    n0,
+    _ISEn,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`InvalidSubnet`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidSubnetException, InvalidSubnetException$1);
+var LBCookieStickinessPolicy = [3, n0, _LBCSP, 0, [_PN, _CEP], [0, 1]];
+var Limit = [3, n0, _Lim, 0, [_N, _Max], [0, 0]];
+var Listener = [3, n0, _Lis, 0, [_P, _LBPo, _IPn, _IP, _SSLCI], [0, 1, 0, 1, 0]];
+var ListenerDescription = [3, n0, _LD, 0, [_Lis, _PNo], [() => Listener, 64 | 0]];
+var ListenerNotFoundException = [
+    -3,
+    n0,
+    _LNFE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`ListenerNotFound`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ListenerNotFoundException, ListenerNotFoundException$1);
+var LoadBalancerAttributeNotFoundException = [
+    -3,
+    n0,
+    _LBANFE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`LoadBalancerAttributeNotFound`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LoadBalancerAttributeNotFoundException, LoadBalancerAttributeNotFoundException$1);
+var LoadBalancerAttributes = [
+    3,
+    n0,
+    _LBA,
+    0,
+    [_CZLB, _AL, _CD, _CS, _AAd],
+    [
+        () => CrossZoneLoadBalancing,
+        () => AccessLog,
+        () => ConnectionDraining,
+        () => ConnectionSettings,
+        () => AdditionalAttributes,
+    ],
+];
+var LoadBalancerDescription = [
+    3,
+    n0,
+    _LBDo,
+    0,
+    [_LBN, _DNSN, _CHZN, _CHZNID, _LDi, _Po, _BSDa, _AZ, _S, _VPCI, _I, _HC, _SSG, _SG, _CT, _Sc],
+    [
+        0,
+        0,
+        0,
+        0,
+        () => ListenerDescriptions,
+        () => Policies,
+        () => BackendServerDescriptions,
+        64 | 0,
+        64 | 0,
+        0,
+        () => Instances,
+        () => HealthCheck,
+        () => SourceSecurityGroup,
+        64 | 0,
+        4,
+        0,
+    ],
+];
+var ModifyLoadBalancerAttributesInput = [
+    3,
+    n0,
+    _MLBAI,
+    0,
+    [_LBN, _LBA],
+    [0, () => LoadBalancerAttributes],
+];
+var ModifyLoadBalancerAttributesOutput = [
+    3,
+    n0,
+    _MLBAO,
+    0,
+    [_LBN, _LBA],
+    [0, () => LoadBalancerAttributes],
+];
+var OperationNotPermittedException = [
+    -3,
+    n0,
+    _ONPE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`OperationNotPermitted`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(OperationNotPermittedException, OperationNotPermittedException$1);
+var Policies = [
+    3,
+    n0,
+    _Po,
+    0,
+    [_ACSPp, _LBCSPo, _OP],
+    [() => AppCookieStickinessPolicies, () => LBCookieStickinessPolicies, 64 | 0],
+];
+var PolicyAttribute = [3, n0, _PAo, 0, [_AN, _AV], [0, 0]];
+var PolicyAttributeDescription = [3, n0, _PAD, 0, [_AN, _AV], [0, 0]];
+var PolicyAttributeTypeDescription = [
+    3,
+    n0,
+    _PATD,
+    0,
+    [_AN, _AT, _D, _DV, _C],
+    [0, 0, 0, 0, 0],
+];
+var PolicyDescription = [
+    3,
+    n0,
+    _PDo,
+    0,
+    [_PN, _PTN, _PADo],
+    [0, 0, () => PolicyAttributeDescriptions],
+];
+var PolicyNotFoundException = [
+    -3,
+    n0,
+    _PNFE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`PolicyNotFound`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(PolicyNotFoundException, PolicyNotFoundException$1);
+var PolicyTypeDescription = [
+    3,
+    n0,
+    _PTDo,
+    0,
+    [_PTN, _D, _PATDo],
+    [0, 0, () => PolicyAttributeTypeDescriptions],
+];
+var PolicyTypeNotFoundException = [
+    -3,
+    n0,
+    _PTNFE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`PolicyTypeNotFound`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(PolicyTypeNotFoundException, PolicyTypeNotFoundException$1);
+var RegisterEndPointsInput = [3, n0, _REPI, 0, [_LBN, _I], [0, () => Instances]];
+var RegisterEndPointsOutput = [3, n0, _REPO, 0, [_I], [() => Instances]];
+var RemoveAvailabilityZonesInput = [3, n0, _RAZI, 0, [_LBN, _AZ], [0, 64 | 0]];
+var RemoveAvailabilityZonesOutput = [3, n0, _RAZO, 0, [_AZ], [64 | 0]];
+var RemoveTagsInput = [3, n0, _RTI, 0, [_LBNo, _T], [64 | 0, () => TagKeyList]];
+var RemoveTagsOutput = [3, n0, _RTO, 0, [], []];
+var SetLoadBalancerListenerSSLCertificateInput = [
+    3,
+    n0,
+    _SLBLSSLCI,
+    0,
+    [_LBN, _LBPo, _SSLCI],
+    [0, 1, 0],
+];
+var SetLoadBalancerListenerSSLCertificateOutput = [3, n0, _SLBLSSLCO, 0, [], []];
+var SetLoadBalancerPoliciesForBackendServerInput = [
+    3,
+    n0,
+    _SLBPFBSI,
+    0,
+    [_LBN, _IP, _PNo],
+    [0, 1, 64 | 0],
+];
+var SetLoadBalancerPoliciesForBackendServerOutput = [3, n0, _SLBPFBSO, 0, [], []];
+var SetLoadBalancerPoliciesOfListenerInput = [
+    3,
+    n0,
+    _SLBPOLI,
+    0,
+    [_LBN, _LBPo, _PNo],
+    [0, 1, 64 | 0],
+];
+var SetLoadBalancerPoliciesOfListenerOutput = [3, n0, _SLBPOLO, 0, [], []];
+var SourceSecurityGroup = [3, n0, _SSG, 0, [_OA, _GN], [0, 0]];
+var SubnetNotFoundException = [
+    -3,
+    n0,
+    _SNFE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`SubnetNotFound`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(SubnetNotFoundException, SubnetNotFoundException$1);
+var Tag = [3, n0, _Tag, 0, [_K, _V], [0, 0]];
+var TagDescription = [3, n0, _TDa, 0, [_LBN, _T], [0, () => TagList]];
+var TagKeyOnly = [3, n0, _TKO, 0, [_K], [0]];
+var TooManyAccessPointsException = [
+    -3,
+    n0,
+    _TMAPE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`TooManyLoadBalancers`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TooManyAccessPointsException, TooManyAccessPointsException$1);
+var TooManyPoliciesException = [
+    -3,
+    n0,
+    _TMPE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`TooManyPolicies`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TooManyPoliciesException, TooManyPoliciesException$1);
+var TooManyTagsException = [
+    -3,
+    n0,
+    _TMTE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`TooManyTags`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TooManyTagsException, TooManyTagsException$1);
+var UnsupportedProtocolException = [
+    -3,
+    n0,
+    _UPE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`UnsupportedProtocol`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(UnsupportedProtocolException, UnsupportedProtocolException$1);
+var ElasticLoadBalancingServiceException = [
+    -3,
+    _s,
+    "ElasticLoadBalancingServiceException",
+    0,
+    [],
+    [],
+];
+schema.TypeRegistry.for(_s).registerError(ElasticLoadBalancingServiceException, ElasticLoadBalancingServiceException$1);
+var AdditionalAttributes = [1, n0, _AAd, 0, () => AdditionalAttribute];
+var AppCookieStickinessPolicies = [1, n0, _ACSPp, 0, () => AppCookieStickinessPolicy];
+var BackendServerDescriptions = [1, n0, _BSDa, 0, () => BackendServerDescription];
+var Instances = [1, n0, _I, 0, () => Instance];
+var InstanceStates = [1, n0, _IS, 0, () => InstanceState];
+var LBCookieStickinessPolicies = [1, n0, _LBCSPo, 0, () => LBCookieStickinessPolicy];
+var Limits = [1, n0, _Li, 0, () => Limit];
+var ListenerDescriptions = [1, n0, _LDi, 0, () => ListenerDescription];
+var Listeners = [1, n0, _L, 0, () => Listener];
+var LoadBalancerDescriptions = [1, n0, _LBD, 0, () => LoadBalancerDescription];
+var PolicyAttributeDescriptions = [1, n0, _PADo, 0, () => PolicyAttributeDescription];
+var PolicyAttributes = [1, n0, _PA, 0, () => PolicyAttribute];
+var PolicyAttributeTypeDescriptions = [1, n0, _PATDo, 0, () => PolicyAttributeTypeDescription];
+var PolicyDescriptions = [1, n0, _PD, 0, () => PolicyDescription];
+var PolicyTypeDescriptions = [1, n0, _PTD, 0, () => PolicyTypeDescription];
+var TagDescriptions = [1, n0, _TD, 0, () => TagDescription];
+var TagKeyList = [1, n0, _TKL, 0, () => TagKeyOnly];
+var TagList = [1, n0, _TL, 0, () => Tag];
+var AddTags = [9, n0, _ATd, 0, () => AddTagsInput, () => AddTagsOutput];
+var ApplySecurityGroupsToLoadBalancer = [
+    9,
+    n0,
+    _ASGTLB,
+    0,
+    () => ApplySecurityGroupsToLoadBalancerInput,
+    () => ApplySecurityGroupsToLoadBalancerOutput,
+];
+var AttachLoadBalancerToSubnets = [
+    9,
+    n0,
+    _ALBTS,
+    0,
+    () => AttachLoadBalancerToSubnetsInput,
+    () => AttachLoadBalancerToSubnetsOutput,
+];
+var ConfigureHealthCheck = [
+    9,
+    n0,
+    _CHC,
+    0,
+    () => ConfigureHealthCheckInput,
+    () => ConfigureHealthCheckOutput,
+];
+var CreateAppCookieStickinessPolicy = [
+    9,
+    n0,
+    _CACSP,
+    0,
+    () => CreateAppCookieStickinessPolicyInput,
+    () => CreateAppCookieStickinessPolicyOutput,
+];
+var CreateLBCookieStickinessPolicy = [
+    9,
+    n0,
+    _CLBCSP,
+    0,
+    () => CreateLBCookieStickinessPolicyInput,
+    () => CreateLBCookieStickinessPolicyOutput,
+];
+var CreateLoadBalancer = [
+    9,
+    n0,
+    _CLB,
+    0,
+    () => CreateAccessPointInput,
+    () => CreateAccessPointOutput,
+];
+var CreateLoadBalancerListeners = [
+    9,
+    n0,
+    _CLBL,
+    0,
+    () => CreateLoadBalancerListenerInput,
+    () => CreateLoadBalancerListenerOutput,
+];
+var CreateLoadBalancerPolicy = [
+    9,
+    n0,
+    _CLBP,
+    0,
+    () => CreateLoadBalancerPolicyInput,
+    () => CreateLoadBalancerPolicyOutput,
+];
+var DeleteLoadBalancer = [
+    9,
+    n0,
+    _DLB,
+    0,
+    () => DeleteAccessPointInput,
+    () => DeleteAccessPointOutput,
+];
+var DeleteLoadBalancerListeners = [
+    9,
+    n0,
+    _DLBL,
+    0,
+    () => DeleteLoadBalancerListenerInput,
+    () => DeleteLoadBalancerListenerOutput,
+];
+var DeleteLoadBalancerPolicy = [
+    9,
+    n0,
+    _DLBP,
+    0,
+    () => DeleteLoadBalancerPolicyInput,
+    () => DeleteLoadBalancerPolicyOutput,
+];
+var DeregisterInstancesFromLoadBalancer = [
+    9,
+    n0,
+    _DIFLB,
+    0,
+    () => DeregisterEndPointsInput,
+    () => DeregisterEndPointsOutput,
+];
+var DescribeAccountLimits = [
+    9,
+    n0,
+    _DAL,
+    0,
+    () => DescribeAccountLimitsInput,
+    () => DescribeAccountLimitsOutput,
+];
+var DescribeInstanceHealth = [
+    9,
+    n0,
+    _DIH,
+    0,
+    () => DescribeEndPointStateInput,
+    () => DescribeEndPointStateOutput,
+];
+var DescribeLoadBalancerAttributes = [
+    9,
+    n0,
+    _DLBA,
+    0,
+    () => DescribeLoadBalancerAttributesInput,
+    () => DescribeLoadBalancerAttributesOutput,
+];
+var DescribeLoadBalancerPolicies = [
+    9,
+    n0,
+    _DLBPe,
+    0,
+    () => DescribeLoadBalancerPoliciesInput,
+    () => DescribeLoadBalancerPoliciesOutput,
+];
+var DescribeLoadBalancerPolicyTypes = [
+    9,
+    n0,
+    _DLBPT,
+    0,
+    () => DescribeLoadBalancerPolicyTypesInput,
+    () => DescribeLoadBalancerPolicyTypesOutput,
+];
+var DescribeLoadBalancers = [
+    9,
+    n0,
+    _DLBe,
+    0,
+    () => DescribeAccessPointsInput,
+    () => DescribeAccessPointsOutput,
+];
+var DescribeTags = [9, n0, _DT, 0, () => DescribeTagsInput, () => DescribeTagsOutput];
+var DetachLoadBalancerFromSubnets = [
+    9,
+    n0,
+    _DLBFS,
+    0,
+    () => DetachLoadBalancerFromSubnetsInput,
+    () => DetachLoadBalancerFromSubnetsOutput,
+];
+var DisableAvailabilityZonesForLoadBalancer = [
+    9,
+    n0,
+    _DAZFLB,
+    0,
+    () => RemoveAvailabilityZonesInput,
+    () => RemoveAvailabilityZonesOutput,
+];
+var EnableAvailabilityZonesForLoadBalancer = [
+    9,
+    n0,
+    _EAZFLB,
+    0,
+    () => AddAvailabilityZonesInput,
+    () => AddAvailabilityZonesOutput,
+];
+var ModifyLoadBalancerAttributes = [
+    9,
+    n0,
+    _MLBA,
+    0,
+    () => ModifyLoadBalancerAttributesInput,
+    () => ModifyLoadBalancerAttributesOutput,
+];
+var RegisterInstancesWithLoadBalancer = [
+    9,
+    n0,
+    _RIWLB,
+    0,
+    () => RegisterEndPointsInput,
+    () => RegisterEndPointsOutput,
+];
+var RemoveTags = [9, n0, _RT, 0, () => RemoveTagsInput, () => RemoveTagsOutput];
+var SetLoadBalancerListenerSSLCertificate = [
+    9,
+    n0,
+    _SLBLSSLC,
+    0,
+    () => SetLoadBalancerListenerSSLCertificateInput,
+    () => SetLoadBalancerListenerSSLCertificateOutput,
+];
+var SetLoadBalancerPoliciesForBackendServer = [
+    9,
+    n0,
+    _SLBPFBS,
+    0,
+    () => SetLoadBalancerPoliciesForBackendServerInput,
+    () => SetLoadBalancerPoliciesForBackendServerOutput,
+];
+var SetLoadBalancerPoliciesOfListener = [
+    9,
+    n0,
+    _SLBPOL,
+    0,
+    () => SetLoadBalancerPoliciesOfListenerInput,
+    () => SetLoadBalancerPoliciesOfListenerOutput,
+];
 
 class AddTagsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "AddTags", {})
     .n("ElasticLoadBalancingClient", "AddTagsCommand")
-    .f(void 0, void 0)
-    .ser(se_AddTagsCommand)
-    .de(de_AddTagsCommand)
+    .sc(AddTags)
     .build() {
 }
 
@@ -3278,16 +1435,11 @@ class ApplySecurityGroupsToLoadBalancerCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "ApplySecurityGroupsToLoadBalancer", {})
     .n("ElasticLoadBalancingClient", "ApplySecurityGroupsToLoadBalancerCommand")
-    .f(void 0, void 0)
-    .ser(se_ApplySecurityGroupsToLoadBalancerCommand)
-    .de(de_ApplySecurityGroupsToLoadBalancerCommand)
+    .sc(ApplySecurityGroupsToLoadBalancer)
     .build() {
 }
 
@@ -3295,16 +1447,11 @@ class AttachLoadBalancerToSubnetsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "AttachLoadBalancerToSubnets", {})
     .n("ElasticLoadBalancingClient", "AttachLoadBalancerToSubnetsCommand")
-    .f(void 0, void 0)
-    .ser(se_AttachLoadBalancerToSubnetsCommand)
-    .de(de_AttachLoadBalancerToSubnetsCommand)
+    .sc(AttachLoadBalancerToSubnets)
     .build() {
 }
 
@@ -3312,16 +1459,11 @@ class ConfigureHealthCheckCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "ConfigureHealthCheck", {})
     .n("ElasticLoadBalancingClient", "ConfigureHealthCheckCommand")
-    .f(void 0, void 0)
-    .ser(se_ConfigureHealthCheckCommand)
-    .de(de_ConfigureHealthCheckCommand)
+    .sc(ConfigureHealthCheck)
     .build() {
 }
 
@@ -3329,16 +1471,11 @@ class CreateAppCookieStickinessPolicyCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "CreateAppCookieStickinessPolicy", {})
     .n("ElasticLoadBalancingClient", "CreateAppCookieStickinessPolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateAppCookieStickinessPolicyCommand)
-    .de(de_CreateAppCookieStickinessPolicyCommand)
+    .sc(CreateAppCookieStickinessPolicy)
     .build() {
 }
 
@@ -3346,16 +1483,11 @@ class CreateLBCookieStickinessPolicyCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "CreateLBCookieStickinessPolicy", {})
     .n("ElasticLoadBalancingClient", "CreateLBCookieStickinessPolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateLBCookieStickinessPolicyCommand)
-    .de(de_CreateLBCookieStickinessPolicyCommand)
+    .sc(CreateLBCookieStickinessPolicy)
     .build() {
 }
 
@@ -3363,16 +1495,11 @@ class CreateLoadBalancerCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "CreateLoadBalancer", {})
     .n("ElasticLoadBalancingClient", "CreateLoadBalancerCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateLoadBalancerCommand)
-    .de(de_CreateLoadBalancerCommand)
+    .sc(CreateLoadBalancer)
     .build() {
 }
 
@@ -3380,16 +1507,11 @@ class CreateLoadBalancerListenersCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "CreateLoadBalancerListeners", {})
     .n("ElasticLoadBalancingClient", "CreateLoadBalancerListenersCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateLoadBalancerListenersCommand)
-    .de(de_CreateLoadBalancerListenersCommand)
+    .sc(CreateLoadBalancerListeners)
     .build() {
 }
 
@@ -3397,16 +1519,11 @@ class CreateLoadBalancerPolicyCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "CreateLoadBalancerPolicy", {})
     .n("ElasticLoadBalancingClient", "CreateLoadBalancerPolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateLoadBalancerPolicyCommand)
-    .de(de_CreateLoadBalancerPolicyCommand)
+    .sc(CreateLoadBalancerPolicy)
     .build() {
 }
 
@@ -3414,16 +1531,11 @@ class DeleteLoadBalancerCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "DeleteLoadBalancer", {})
     .n("ElasticLoadBalancingClient", "DeleteLoadBalancerCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteLoadBalancerCommand)
-    .de(de_DeleteLoadBalancerCommand)
+    .sc(DeleteLoadBalancer)
     .build() {
 }
 
@@ -3431,16 +1543,11 @@ class DeleteLoadBalancerListenersCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "DeleteLoadBalancerListeners", {})
     .n("ElasticLoadBalancingClient", "DeleteLoadBalancerListenersCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteLoadBalancerListenersCommand)
-    .de(de_DeleteLoadBalancerListenersCommand)
+    .sc(DeleteLoadBalancerListeners)
     .build() {
 }
 
@@ -3448,16 +1555,11 @@ class DeleteLoadBalancerPolicyCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "DeleteLoadBalancerPolicy", {})
     .n("ElasticLoadBalancingClient", "DeleteLoadBalancerPolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteLoadBalancerPolicyCommand)
-    .de(de_DeleteLoadBalancerPolicyCommand)
+    .sc(DeleteLoadBalancerPolicy)
     .build() {
 }
 
@@ -3465,16 +1567,11 @@ class DeregisterInstancesFromLoadBalancerCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "DeregisterInstancesFromLoadBalancer", {})
     .n("ElasticLoadBalancingClient", "DeregisterInstancesFromLoadBalancerCommand")
-    .f(void 0, void 0)
-    .ser(se_DeregisterInstancesFromLoadBalancerCommand)
-    .de(de_DeregisterInstancesFromLoadBalancerCommand)
+    .sc(DeregisterInstancesFromLoadBalancer)
     .build() {
 }
 
@@ -3482,16 +1579,11 @@ class DescribeAccountLimitsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "DescribeAccountLimits", {})
     .n("ElasticLoadBalancingClient", "DescribeAccountLimitsCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeAccountLimitsCommand)
-    .de(de_DescribeAccountLimitsCommand)
+    .sc(DescribeAccountLimits)
     .build() {
 }
 
@@ -3499,16 +1591,11 @@ class DescribeInstanceHealthCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "DescribeInstanceHealth", {})
     .n("ElasticLoadBalancingClient", "DescribeInstanceHealthCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeInstanceHealthCommand)
-    .de(de_DescribeInstanceHealthCommand)
+    .sc(DescribeInstanceHealth)
     .build() {
 }
 
@@ -3516,16 +1603,11 @@ class DescribeLoadBalancerAttributesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "DescribeLoadBalancerAttributes", {})
     .n("ElasticLoadBalancingClient", "DescribeLoadBalancerAttributesCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeLoadBalancerAttributesCommand)
-    .de(de_DescribeLoadBalancerAttributesCommand)
+    .sc(DescribeLoadBalancerAttributes)
     .build() {
 }
 
@@ -3533,16 +1615,11 @@ class DescribeLoadBalancerPoliciesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "DescribeLoadBalancerPolicies", {})
     .n("ElasticLoadBalancingClient", "DescribeLoadBalancerPoliciesCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeLoadBalancerPoliciesCommand)
-    .de(de_DescribeLoadBalancerPoliciesCommand)
+    .sc(DescribeLoadBalancerPolicies)
     .build() {
 }
 
@@ -3550,16 +1627,11 @@ class DescribeLoadBalancerPolicyTypesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "DescribeLoadBalancerPolicyTypes", {})
     .n("ElasticLoadBalancingClient", "DescribeLoadBalancerPolicyTypesCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeLoadBalancerPolicyTypesCommand)
-    .de(de_DescribeLoadBalancerPolicyTypesCommand)
+    .sc(DescribeLoadBalancerPolicyTypes)
     .build() {
 }
 
@@ -3567,16 +1639,11 @@ class DescribeLoadBalancersCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "DescribeLoadBalancers", {})
     .n("ElasticLoadBalancingClient", "DescribeLoadBalancersCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeLoadBalancersCommand)
-    .de(de_DescribeLoadBalancersCommand)
+    .sc(DescribeLoadBalancers)
     .build() {
 }
 
@@ -3584,16 +1651,11 @@ class DescribeTagsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "DescribeTags", {})
     .n("ElasticLoadBalancingClient", "DescribeTagsCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeTagsCommand)
-    .de(de_DescribeTagsCommand)
+    .sc(DescribeTags)
     .build() {
 }
 
@@ -3601,16 +1663,11 @@ class DetachLoadBalancerFromSubnetsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "DetachLoadBalancerFromSubnets", {})
     .n("ElasticLoadBalancingClient", "DetachLoadBalancerFromSubnetsCommand")
-    .f(void 0, void 0)
-    .ser(se_DetachLoadBalancerFromSubnetsCommand)
-    .de(de_DetachLoadBalancerFromSubnetsCommand)
+    .sc(DetachLoadBalancerFromSubnets)
     .build() {
 }
 
@@ -3618,16 +1675,11 @@ class DisableAvailabilityZonesForLoadBalancerCommand extends smithyClient.Comman
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "DisableAvailabilityZonesForLoadBalancer", {})
     .n("ElasticLoadBalancingClient", "DisableAvailabilityZonesForLoadBalancerCommand")
-    .f(void 0, void 0)
-    .ser(se_DisableAvailabilityZonesForLoadBalancerCommand)
-    .de(de_DisableAvailabilityZonesForLoadBalancerCommand)
+    .sc(DisableAvailabilityZonesForLoadBalancer)
     .build() {
 }
 
@@ -3635,16 +1687,11 @@ class EnableAvailabilityZonesForLoadBalancerCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "EnableAvailabilityZonesForLoadBalancer", {})
     .n("ElasticLoadBalancingClient", "EnableAvailabilityZonesForLoadBalancerCommand")
-    .f(void 0, void 0)
-    .ser(se_EnableAvailabilityZonesForLoadBalancerCommand)
-    .de(de_EnableAvailabilityZonesForLoadBalancerCommand)
+    .sc(EnableAvailabilityZonesForLoadBalancer)
     .build() {
 }
 
@@ -3652,16 +1699,11 @@ class ModifyLoadBalancerAttributesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "ModifyLoadBalancerAttributes", {})
     .n("ElasticLoadBalancingClient", "ModifyLoadBalancerAttributesCommand")
-    .f(void 0, void 0)
-    .ser(se_ModifyLoadBalancerAttributesCommand)
-    .de(de_ModifyLoadBalancerAttributesCommand)
+    .sc(ModifyLoadBalancerAttributes)
     .build() {
 }
 
@@ -3669,16 +1711,11 @@ class RegisterInstancesWithLoadBalancerCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "RegisterInstancesWithLoadBalancer", {})
     .n("ElasticLoadBalancingClient", "RegisterInstancesWithLoadBalancerCommand")
-    .f(void 0, void 0)
-    .ser(se_RegisterInstancesWithLoadBalancerCommand)
-    .de(de_RegisterInstancesWithLoadBalancerCommand)
+    .sc(RegisterInstancesWithLoadBalancer)
     .build() {
 }
 
@@ -3686,16 +1723,11 @@ class RemoveTagsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "RemoveTags", {})
     .n("ElasticLoadBalancingClient", "RemoveTagsCommand")
-    .f(void 0, void 0)
-    .ser(se_RemoveTagsCommand)
-    .de(de_RemoveTagsCommand)
+    .sc(RemoveTags)
     .build() {
 }
 
@@ -3703,16 +1735,11 @@ class SetLoadBalancerListenerSSLCertificateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "SetLoadBalancerListenerSSLCertificate", {})
     .n("ElasticLoadBalancingClient", "SetLoadBalancerListenerSSLCertificateCommand")
-    .f(void 0, void 0)
-    .ser(se_SetLoadBalancerListenerSSLCertificateCommand)
-    .de(de_SetLoadBalancerListenerSSLCertificateCommand)
+    .sc(SetLoadBalancerListenerSSLCertificate)
     .build() {
 }
 
@@ -3720,16 +1747,11 @@ class SetLoadBalancerPoliciesForBackendServerCommand extends smithyClient.Comman
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "SetLoadBalancerPoliciesForBackendServer", {})
     .n("ElasticLoadBalancingClient", "SetLoadBalancerPoliciesForBackendServerCommand")
-    .f(void 0, void 0)
-    .ser(se_SetLoadBalancerPoliciesForBackendServerCommand)
-    .de(de_SetLoadBalancerPoliciesForBackendServerCommand)
+    .sc(SetLoadBalancerPoliciesForBackendServer)
     .build() {
 }
 
@@ -3737,16 +1759,11 @@ class SetLoadBalancerPoliciesOfListenerCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticLoadBalancing_v7", "SetLoadBalancerPoliciesOfListener", {})
     .n("ElasticLoadBalancingClient", "SetLoadBalancerPoliciesOfListenerCommand")
-    .f(void 0, void 0)
-    .ser(se_SetLoadBalancerPoliciesOfListenerCommand)
-    .de(de_SetLoadBalancerPoliciesOfListenerCommand)
+    .sc(SetLoadBalancerPoliciesOfListener)
     .build() {
 }
 
@@ -3913,11 +1930,11 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessPointNotFoundException = AccessPointNotFoundException;
+exports.AccessPointNotFoundException = AccessPointNotFoundException$1;
 exports.AddTagsCommand = AddTagsCommand;
 exports.ApplySecurityGroupsToLoadBalancerCommand = ApplySecurityGroupsToLoadBalancerCommand;
 exports.AttachLoadBalancerToSubnetsCommand = AttachLoadBalancerToSubnetsCommand;
-exports.CertificateNotFoundException = CertificateNotFoundException;
+exports.CertificateNotFoundException = CertificateNotFoundException$1;
 exports.ConfigureHealthCheckCommand = ConfigureHealthCheckCommand;
 exports.CreateAppCookieStickinessPolicyCommand = CreateAppCookieStickinessPolicyCommand;
 exports.CreateLBCookieStickinessPolicyCommand = CreateLBCookieStickinessPolicyCommand;
@@ -3927,7 +1944,7 @@ exports.CreateLoadBalancerPolicyCommand = CreateLoadBalancerPolicyCommand;
 exports.DeleteLoadBalancerCommand = DeleteLoadBalancerCommand;
 exports.DeleteLoadBalancerListenersCommand = DeleteLoadBalancerListenersCommand;
 exports.DeleteLoadBalancerPolicyCommand = DeleteLoadBalancerPolicyCommand;
-exports.DependencyThrottleException = DependencyThrottleException;
+exports.DependencyThrottleException = DependencyThrottleException$1;
 exports.DeregisterInstancesFromLoadBalancerCommand = DeregisterInstancesFromLoadBalancerCommand;
 exports.DescribeAccountLimitsCommand = DescribeAccountLimitsCommand;
 exports.DescribeInstanceHealthCommand = DescribeInstanceHealthCommand;
@@ -3938,35 +1955,35 @@ exports.DescribeLoadBalancersCommand = DescribeLoadBalancersCommand;
 exports.DescribeTagsCommand = DescribeTagsCommand;
 exports.DetachLoadBalancerFromSubnetsCommand = DetachLoadBalancerFromSubnetsCommand;
 exports.DisableAvailabilityZonesForLoadBalancerCommand = DisableAvailabilityZonesForLoadBalancerCommand;
-exports.DuplicateAccessPointNameException = DuplicateAccessPointNameException;
-exports.DuplicateListenerException = DuplicateListenerException;
-exports.DuplicatePolicyNameException = DuplicatePolicyNameException;
-exports.DuplicateTagKeysException = DuplicateTagKeysException;
+exports.DuplicateAccessPointNameException = DuplicateAccessPointNameException$1;
+exports.DuplicateListenerException = DuplicateListenerException$1;
+exports.DuplicatePolicyNameException = DuplicatePolicyNameException$1;
+exports.DuplicateTagKeysException = DuplicateTagKeysException$1;
 exports.ElasticLoadBalancing = ElasticLoadBalancing;
 exports.ElasticLoadBalancingClient = ElasticLoadBalancingClient;
-exports.ElasticLoadBalancingServiceException = ElasticLoadBalancingServiceException;
+exports.ElasticLoadBalancingServiceException = ElasticLoadBalancingServiceException$1;
 exports.EnableAvailabilityZonesForLoadBalancerCommand = EnableAvailabilityZonesForLoadBalancerCommand;
-exports.InvalidConfigurationRequestException = InvalidConfigurationRequestException;
-exports.InvalidEndPointException = InvalidEndPointException;
-exports.InvalidSchemeException = InvalidSchemeException;
-exports.InvalidSecurityGroupException = InvalidSecurityGroupException;
-exports.InvalidSubnetException = InvalidSubnetException;
-exports.ListenerNotFoundException = ListenerNotFoundException;
-exports.LoadBalancerAttributeNotFoundException = LoadBalancerAttributeNotFoundException;
+exports.InvalidConfigurationRequestException = InvalidConfigurationRequestException$1;
+exports.InvalidEndPointException = InvalidEndPointException$1;
+exports.InvalidSchemeException = InvalidSchemeException$1;
+exports.InvalidSecurityGroupException = InvalidSecurityGroupException$1;
+exports.InvalidSubnetException = InvalidSubnetException$1;
+exports.ListenerNotFoundException = ListenerNotFoundException$1;
+exports.LoadBalancerAttributeNotFoundException = LoadBalancerAttributeNotFoundException$1;
 exports.ModifyLoadBalancerAttributesCommand = ModifyLoadBalancerAttributesCommand;
-exports.OperationNotPermittedException = OperationNotPermittedException;
-exports.PolicyNotFoundException = PolicyNotFoundException;
-exports.PolicyTypeNotFoundException = PolicyTypeNotFoundException;
+exports.OperationNotPermittedException = OperationNotPermittedException$1;
+exports.PolicyNotFoundException = PolicyNotFoundException$1;
+exports.PolicyTypeNotFoundException = PolicyTypeNotFoundException$1;
 exports.RegisterInstancesWithLoadBalancerCommand = RegisterInstancesWithLoadBalancerCommand;
 exports.RemoveTagsCommand = RemoveTagsCommand;
 exports.SetLoadBalancerListenerSSLCertificateCommand = SetLoadBalancerListenerSSLCertificateCommand;
 exports.SetLoadBalancerPoliciesForBackendServerCommand = SetLoadBalancerPoliciesForBackendServerCommand;
 exports.SetLoadBalancerPoliciesOfListenerCommand = SetLoadBalancerPoliciesOfListenerCommand;
-exports.SubnetNotFoundException = SubnetNotFoundException;
-exports.TooManyAccessPointsException = TooManyAccessPointsException;
-exports.TooManyPoliciesException = TooManyPoliciesException;
-exports.TooManyTagsException = TooManyTagsException;
-exports.UnsupportedProtocolException = UnsupportedProtocolException;
+exports.SubnetNotFoundException = SubnetNotFoundException$1;
+exports.TooManyAccessPointsException = TooManyAccessPointsException$1;
+exports.TooManyPoliciesException = TooManyPoliciesException$1;
+exports.TooManyTagsException = TooManyTagsException$1;
+exports.UnsupportedProtocolException = UnsupportedProtocolException$1;
 exports.paginateDescribeLoadBalancers = paginateDescribeLoadBalancers;
 exports.waitForAnyInstanceInService = waitForAnyInstanceInService;
 exports.waitForInstanceDeregistered = waitForInstanceDeregistered;