@aws-sdk/client-elastic-load-balancing 3.504.0 → 3.509.0

package/dist-es/protocols/Aws_query.js

@@ -295,7 +295,7 @@ export const se_SetLoadBalancerPoliciesOfListenerCommand = async (input, context
 };
 export const de_AddTagsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_AddTagsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -306,34 +306,9 @@ export const de_AddTagsCommand = async (output, context) => {
     };
     return response;
 };
-const de_AddTagsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "DuplicateTagKeys":
-        case "com.amazonaws.elasticloadbalancing#DuplicateTagKeysException":
-            throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        case "TooManyTags":
-        case "com.amazonaws.elasticloadbalancing#TooManyTagsException":
-            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_ApplySecurityGroupsToLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ApplySecurityGroupsToLoadBalancerCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -344,34 +319,9 @@ export const de_ApplySecurityGroupsToLoadBalancerCommand = async (output, contex
     };
     return response;
 };
-const de_ApplySecurityGroupsToLoadBalancerCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "InvalidSecurityGroup":
-        case "com.amazonaws.elasticloadbalancing#InvalidSecurityGroupException":
-            throw await de_InvalidSecurityGroupExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_AttachLoadBalancerToSubnetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_AttachLoadBalancerToSubnetsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -382,37 +332,9 @@ export const de_AttachLoadBalancerToSubnetsCommand = async (output, context) =>
     };
     return response;
 };
-const de_AttachLoadBalancerToSubnetsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "InvalidSubnet":
-        case "com.amazonaws.elasticloadbalancing#InvalidSubnetException":
-            throw await de_InvalidSubnetExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        case "SubnetNotFound":
-        case "com.amazonaws.elasticloadbalancing#SubnetNotFoundException":
-            throw await de_SubnetNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_ConfigureHealthCheckCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ConfigureHealthCheckCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -423,28 +345,9 @@ export const de_ConfigureHealthCheckCommand = async (output, context) => {
     };
     return response;
 };
-const de_ConfigureHealthCheckCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateAppCookieStickinessPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateAppCookieStickinessPolicyCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -455,37 +358,9 @@ export const de_CreateAppCookieStickinessPolicyCommand = async (output, context)
     };
     return response;
 };
-const de_CreateAppCookieStickinessPolicyCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "DuplicatePolicyName":
-        case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException":
-            throw await de_DuplicatePolicyNameExceptionRes(parsedOutput, context);
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        case "TooManyPolicies":
-        case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException":
-            throw await de_TooManyPoliciesExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateLBCookieStickinessPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateLBCookieStickinessPolicyCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -496,37 +371,9 @@ export const de_CreateLBCookieStickinessPolicyCommand = async (output, context)
     };
     return response;
 };
-const de_CreateLBCookieStickinessPolicyCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "DuplicatePolicyName":
-        case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException":
-            throw await de_DuplicatePolicyNameExceptionRes(parsedOutput, context);
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        case "TooManyPolicies":
-        case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException":
-            throw await de_TooManyPoliciesExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateLoadBalancerCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -537,61 +384,9 @@ export const de_CreateLoadBalancerCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateLoadBalancerCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CertificateNotFound":
-        case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException":
-            throw await de_CertificateNotFoundExceptionRes(parsedOutput, context);
-        case "DuplicateLoadBalancerName":
-        case "com.amazonaws.elasticloadbalancing#DuplicateAccessPointNameException":
-            throw await de_DuplicateAccessPointNameExceptionRes(parsedOutput, context);
-        case "DuplicateTagKeys":
-        case "com.amazonaws.elasticloadbalancing#DuplicateTagKeysException":
-            throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "InvalidScheme":
-        case "com.amazonaws.elasticloadbalancing#InvalidSchemeException":
-            throw await de_InvalidSchemeExceptionRes(parsedOutput, context);
-        case "InvalidSecurityGroup":
-        case "com.amazonaws.elasticloadbalancing#InvalidSecurityGroupException":
-            throw await de_InvalidSecurityGroupExceptionRes(parsedOutput, context);
-        case "InvalidSubnet":
-        case "com.amazonaws.elasticloadbalancing#InvalidSubnetException":
-            throw await de_InvalidSubnetExceptionRes(parsedOutput, context);
-        case "OperationNotPermitted":
-        case "com.amazonaws.elasticloadbalancing#OperationNotPermittedException":
-            throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
-        case "SubnetNotFound":
-        case "com.amazonaws.elasticloadbalancing#SubnetNotFoundException":
-            throw await de_SubnetNotFoundExceptionRes(parsedOutput, context);
-        case "TooManyLoadBalancers":
-        case "com.amazonaws.elasticloadbalancing#TooManyAccessPointsException":
-            throw await de_TooManyAccessPointsExceptionRes(parsedOutput, context);
-        case "TooManyTags":
-        case "com.amazonaws.elasticloadbalancing#TooManyTagsException":
-            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
-        case "UnsupportedProtocol":
-        case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException":
-            throw await de_UnsupportedProtocolExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateLoadBalancerListenersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateLoadBalancerListenersCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -602,40 +397,9 @@ export const de_CreateLoadBalancerListenersCommand = async (output, context) =>
     };
     return response;
 };
-const de_CreateLoadBalancerListenersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CertificateNotFound":
-        case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException":
-            throw await de_CertificateNotFoundExceptionRes(parsedOutput, context);
-        case "DuplicateListener":
-        case "com.amazonaws.elasticloadbalancing#DuplicateListenerException":
-            throw await de_DuplicateListenerExceptionRes(parsedOutput, context);
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        case "UnsupportedProtocol":
-        case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException":
-            throw await de_UnsupportedProtocolExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateLoadBalancerPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateLoadBalancerPolicyCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -646,40 +410,9 @@ export const de_CreateLoadBalancerPolicyCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateLoadBalancerPolicyCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "DuplicatePolicyName":
-        case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException":
-            throw await de_DuplicatePolicyNameExceptionRes(parsedOutput, context);
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        case "PolicyTypeNotFound":
-        case "com.amazonaws.elasticloadbalancing#PolicyTypeNotFoundException":
-            throw await de_PolicyTypeNotFoundExceptionRes(parsedOutput, context);
-        case "TooManyPolicies":
-        case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException":
-            throw await de_TooManyPoliciesExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteLoadBalancerCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -690,22 +423,9 @@ export const de_DeleteLoadBalancerCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteLoadBalancerCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    const parsedBody = parsedOutput.body;
-    return throwDefaultError({
-        output,
-        parsedBody: parsedBody.Error,
-        errorCode,
-    });
-};
 export const de_DeleteLoadBalancerListenersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteLoadBalancerListenersCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -716,28 +436,9 @@ export const de_DeleteLoadBalancerListenersCommand = async (output, context) =>
     };
     return response;
 };
-const de_DeleteLoadBalancerListenersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteLoadBalancerPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteLoadBalancerPolicyCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -748,31 +449,9 @@ export const de_DeleteLoadBalancerPolicyCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteLoadBalancerPolicyCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DeregisterInstancesFromLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeregisterInstancesFromLoadBalancerCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -783,31 +462,9 @@ export const de_DeregisterInstancesFromLoadBalancerCommand = async (output, cont
     };
     return response;
 };
-const de_DeregisterInstancesFromLoadBalancerCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidInstance":
-        case "com.amazonaws.elasticloadbalancing#InvalidEndPointException":
-            throw await de_InvalidEndPointExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeAccountLimitsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeAccountLimitsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -818,22 +475,9 @@ export const de_DescribeAccountLimitsCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeAccountLimitsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    const parsedBody = parsedOutput.body;
-    return throwDefaultError({
-        output,
-        parsedBody: parsedBody.Error,
-        errorCode,
-    });
-};
 export const de_DescribeInstanceHealthCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeInstanceHealthCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -844,31 +488,9 @@ export const de_DescribeInstanceHealthCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeInstanceHealthCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidInstance":
-        case "com.amazonaws.elasticloadbalancing#InvalidEndPointException":
-            throw await de_InvalidEndPointExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeLoadBalancerAttributesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeLoadBalancerAttributesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -879,31 +501,9 @@ export const de_DescribeLoadBalancerAttributesCommand = async (output, context)
     };
     return response;
 };
-const de_DescribeLoadBalancerAttributesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "LoadBalancerAttributeNotFound":
-        case "com.amazonaws.elasticloadbalancing#LoadBalancerAttributeNotFoundException":
-            throw await de_LoadBalancerAttributeNotFoundExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeLoadBalancerPoliciesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeLoadBalancerPoliciesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -914,31 +514,9 @@ export const de_DescribeLoadBalancerPoliciesCommand = async (output, context) =>
     };
     return response;
 };
-const de_DescribeLoadBalancerPoliciesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        case "PolicyNotFound":
-        case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException":
-            throw await de_PolicyNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeLoadBalancerPolicyTypesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeLoadBalancerPolicyTypesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -949,28 +527,9 @@ export const de_DescribeLoadBalancerPolicyTypesCommand = async (output, context)
     };
     return response;
 };
-const de_DescribeLoadBalancerPolicyTypesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "PolicyTypeNotFound":
-        case "com.amazonaws.elasticloadbalancing#PolicyTypeNotFoundException":
-            throw await de_PolicyTypeNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeLoadBalancersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeLoadBalancersCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -978,66 +537,25 @@ export const de_DescribeLoadBalancersCommand = async (output, context) => {
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
-    };
-    return response;
-};
-const de_DescribeLoadBalancersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "DependencyThrottle":
-        case "com.amazonaws.elasticloadbalancing#DependencyThrottleException":
-            throw await de_DependencyThrottleExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeTagsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DescribeTagsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeTagsOutput(data.DescribeTagsResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeTagsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
+    };
+    return response;
+};
+export const de_DescribeTagsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeTagsOutput(data.DescribeTagsResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
 export const de_DetachLoadBalancerFromSubnetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DetachLoadBalancerFromSubnetsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1048,31 +566,9 @@ export const de_DetachLoadBalancerFromSubnetsCommand = async (output, context) =
     };
     return response;
 };
-const de_DetachLoadBalancerFromSubnetsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DisableAvailabilityZonesForLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DisableAvailabilityZonesForLoadBalancerCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1083,31 +579,9 @@ export const de_DisableAvailabilityZonesForLoadBalancerCommand = async (output,
     };
     return response;
 };
-const de_DisableAvailabilityZonesForLoadBalancerCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_EnableAvailabilityZonesForLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_EnableAvailabilityZonesForLoadBalancerCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1118,28 +592,9 @@ export const de_EnableAvailabilityZonesForLoadBalancerCommand = async (output, c
     };
     return response;
 };
-const de_EnableAvailabilityZonesForLoadBalancerCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_ModifyLoadBalancerAttributesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ModifyLoadBalancerAttributesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1150,34 +605,9 @@ export const de_ModifyLoadBalancerAttributesCommand = async (output, context) =>
     };
     return response;
 };
-const de_ModifyLoadBalancerAttributesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "LoadBalancerAttributeNotFound":
-        case "com.amazonaws.elasticloadbalancing#LoadBalancerAttributeNotFoundException":
-            throw await de_LoadBalancerAttributeNotFoundExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_RegisterInstancesWithLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RegisterInstancesWithLoadBalancerCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1188,31 +618,9 @@ export const de_RegisterInstancesWithLoadBalancerCommand = async (output, contex
     };
     return response;
 };
-const de_RegisterInstancesWithLoadBalancerCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidInstance":
-        case "com.amazonaws.elasticloadbalancing#InvalidEndPointException":
-            throw await de_InvalidEndPointExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_RemoveTagsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RemoveTagsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1223,28 +631,9 @@ export const de_RemoveTagsCommand = async (output, context) => {
     };
     return response;
 };
-const de_RemoveTagsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_SetLoadBalancerListenerSSLCertificateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_SetLoadBalancerListenerSSLCertificateCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1255,40 +644,9 @@ export const de_SetLoadBalancerListenerSSLCertificateCommand = async (output, co
     };
     return response;
 };
-const de_SetLoadBalancerListenerSSLCertificateCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CertificateNotFound":
-        case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException":
-            throw await de_CertificateNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "ListenerNotFound":
-        case "com.amazonaws.elasticloadbalancing#ListenerNotFoundException":
-            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        case "UnsupportedProtocol":
-        case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException":
-            throw await de_UnsupportedProtocolExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_SetLoadBalancerPoliciesForBackendServerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_SetLoadBalancerPoliciesForBackendServerCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1299,34 +657,9 @@ export const de_SetLoadBalancerPoliciesForBackendServerCommand = async (output,
     };
     return response;
 };
-const de_SetLoadBalancerPoliciesForBackendServerCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
-        case "PolicyNotFound":
-        case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException":
-            throw await de_PolicyNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_SetLoadBalancerPoliciesOfListenerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_SetLoadBalancerPoliciesOfListenerCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1337,25 +670,79 @@ export const de_SetLoadBalancerPoliciesOfListenerCommand = async (output, contex
     };
     return response;
 };
-const de_SetLoadBalancerPoliciesOfListenerCommandError = async (output, context) => {
+const de_CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadQueryErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "ListenerNotFound":
-        case "com.amazonaws.elasticloadbalancing#ListenerNotFoundException":
-            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
+        case "DuplicateTagKeys":
+        case "com.amazonaws.elasticloadbalancing#DuplicateTagKeysException":
+            throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
         case "LoadBalancerNotFound":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
             throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+        case "TooManyTags":
+        case "com.amazonaws.elasticloadbalancing#TooManyTagsException":
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+        case "InvalidConfigurationRequest":
+        case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
+            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+        case "InvalidSecurityGroup":
+        case "com.amazonaws.elasticloadbalancing#InvalidSecurityGroupException":
+            throw await de_InvalidSecurityGroupExceptionRes(parsedOutput, context);
+        case "InvalidSubnet":
+        case "com.amazonaws.elasticloadbalancing#InvalidSubnetException":
+            throw await de_InvalidSubnetExceptionRes(parsedOutput, context);
+        case "SubnetNotFound":
+        case "com.amazonaws.elasticloadbalancing#SubnetNotFoundException":
+            throw await de_SubnetNotFoundExceptionRes(parsedOutput, context);
+        case "DuplicatePolicyName":
+        case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException":
+            throw await de_DuplicatePolicyNameExceptionRes(parsedOutput, context);
+        case "TooManyPolicies":
+        case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException":
+            throw await de_TooManyPoliciesExceptionRes(parsedOutput, context);
+        case "CertificateNotFound":
+        case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException":
+            throw await de_CertificateNotFoundExceptionRes(parsedOutput, context);
+        case "DuplicateLoadBalancerName":
+        case "com.amazonaws.elasticloadbalancing#DuplicateAccessPointNameException":
+            throw await de_DuplicateAccessPointNameExceptionRes(parsedOutput, context);
+        case "InvalidScheme":
+        case "com.amazonaws.elasticloadbalancing#InvalidSchemeException":
+            throw await de_InvalidSchemeExceptionRes(parsedOutput, context);
+        case "OperationNotPermitted":
+        case "com.amazonaws.elasticloadbalancing#OperationNotPermittedException":
+            throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
+        case "TooManyLoadBalancers":
+        case "com.amazonaws.elasticloadbalancing#TooManyAccessPointsException":
+            throw await de_TooManyAccessPointsExceptionRes(parsedOutput, context);
+        case "UnsupportedProtocol":
+        case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException":
+            throw await de_UnsupportedProtocolExceptionRes(parsedOutput, context);
+        case "DuplicateListener":
+        case "com.amazonaws.elasticloadbalancing#DuplicateListenerException":
+            throw await de_DuplicateListenerExceptionRes(parsedOutput, context);
+        case "PolicyTypeNotFound":
+        case "com.amazonaws.elasticloadbalancing#PolicyTypeNotFoundException":
+            throw await de_PolicyTypeNotFoundExceptionRes(parsedOutput, context);
+        case "InvalidInstance":
+        case "com.amazonaws.elasticloadbalancing#InvalidEndPointException":
+            throw await de_InvalidEndPointExceptionRes(parsedOutput, context);
+        case "LoadBalancerAttributeNotFound":
+        case "com.amazonaws.elasticloadbalancing#LoadBalancerAttributeNotFoundException":
+            throw await de_LoadBalancerAttributeNotFoundExceptionRes(parsedOutput, context);
         case "PolicyNotFound":
         case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException":
             throw await de_PolicyNotFoundExceptionRes(parsedOutput, context);
+        case "DependencyThrottle":
+        case "com.amazonaws.elasticloadbalancing#DependencyThrottleException":
+            throw await de_DependencyThrottleExceptionRes(parsedOutput, context);
+        case "ListenerNotFound":
+        case "com.amazonaws.elasticloadbalancing#ListenerNotFoundException":
+            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({