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

package/dist-es/protocols/Aws_query.js

@@ -445,7 +445,7 @@ export const se_SetSubnetsCommand = async (input, context) => {
 };
 export const de_AddListenerCertificatesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_AddListenerCertificatesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -456,34 +456,9 @@ export const de_AddListenerCertificatesCommand = async (output, context) => {
     };
     return response;
 };
-const de_AddListenerCertificatesCommandError = 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.elasticloadbalancingv2#CertificateNotFoundException":
-            throw await de_CertificateNotFoundExceptionRes(parsedOutput, context);
-        case "ListenerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
-        case "TooManyCertificates":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyCertificatesException":
-            throw await de_TooManyCertificatesExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 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 = {};
@@ -494,46 +469,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.elasticloadbalancingv2#DuplicateTagKeysException":
-            throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
-        case "ListenerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            throw await de_LoadBalancerNotFoundExceptionRes(parsedOutput, context);
-        case "RuleNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
-            throw await de_RuleNotFoundExceptionRes(parsedOutput, context);
-        case "TargetGroupNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            throw await de_TargetGroupNotFoundExceptionRes(parsedOutput, context);
-        case "TooManyTags":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
-            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
-        case "TrustStoreNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotFoundException":
-            throw await de_TrustStoreNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_AddTrustStoreRevocationsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_AddTrustStoreRevocationsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -544,37 +482,9 @@ export const de_AddTrustStoreRevocationsCommand = async (output, context) => {
     };
     return response;
 };
-const de_AddTrustStoreRevocationsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidRevocationContent":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidRevocationContentException":
-            throw await de_InvalidRevocationContentExceptionRes(parsedOutput, context);
-        case "RevocationContentNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#RevocationContentNotFoundException":
-            throw await de_RevocationContentNotFoundExceptionRes(parsedOutput, context);
-        case "TooManyTrustStoreRevocationEntries":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyTrustStoreRevocationEntriesException":
-            throw await de_TooManyTrustStoreRevocationEntriesExceptionRes(parsedOutput, context);
-        case "TrustStoreNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotFoundException":
-            throw await de_TrustStoreNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateListenerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateListenerCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -585,85 +495,9 @@ export const de_CreateListenerCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateListenerCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ALPNPolicyNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#ALPNPolicyNotSupportedException":
-            throw await de_ALPNPolicyNotSupportedExceptionRes(parsedOutput, context);
-        case "CertificateNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#CertificateNotFoundException":
-            throw await de_CertificateNotFoundExceptionRes(parsedOutput, context);
-        case "DuplicateListener":
-        case "com.amazonaws.elasticloadbalancingv2#DuplicateListenerException":
-            throw await de_DuplicateListenerExceptionRes(parsedOutput, context);
-        case "IncompatibleProtocols":
-        case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
-            throw await de_IncompatibleProtocolsExceptionRes(parsedOutput, context);
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "InvalidLoadBalancerAction":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
-            throw await de_InvalidLoadBalancerActionExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            throw await de_LoadBalancerNotFoundExceptionRes(parsedOutput, context);
-        case "SSLPolicyNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#SSLPolicyNotFoundException":
-            throw await de_SSLPolicyNotFoundExceptionRes(parsedOutput, context);
-        case "TargetGroupAssociationLimit":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
-            throw await de_TargetGroupAssociationLimitExceptionRes(parsedOutput, context);
-        case "TargetGroupNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            throw await de_TargetGroupNotFoundExceptionRes(parsedOutput, context);
-        case "TooManyActions":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
-            throw await de_TooManyActionsExceptionRes(parsedOutput, context);
-        case "TooManyCertificates":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyCertificatesException":
-            throw await de_TooManyCertificatesExceptionRes(parsedOutput, context);
-        case "TooManyListeners":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyListenersException":
-            throw await de_TooManyListenersExceptionRes(parsedOutput, context);
-        case "TooManyRegistrationsForTargetId":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
-            throw await de_TooManyRegistrationsForTargetIdExceptionRes(parsedOutput, context);
-        case "TooManyTags":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
-            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
-        case "TooManyTargets":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
-            throw await de_TooManyTargetsExceptionRes(parsedOutput, context);
-        case "TooManyUniqueTargetGroupsPerLoadBalancer":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
-            throw await de_TooManyUniqueTargetGroupsPerLoadBalancerExceptionRes(parsedOutput, context);
-        case "TrustStoreNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotFoundException":
-            throw await de_TrustStoreNotFoundExceptionRes(parsedOutput, context);
-        case "TrustStoreNotReady":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotReadyException":
-            throw await de_TrustStoreNotReadyExceptionRes(parsedOutput, context);
-        case "UnsupportedProtocol":
-        case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
-            throw await de_UnsupportedProtocolExceptionRes(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 = {};
@@ -674,64 +508,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 "AllocationIdNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#AllocationIdNotFoundException":
-            throw await de_AllocationIdNotFoundExceptionRes(parsedOutput, context);
-        case "AvailabilityZoneNotSupported":
-        case "com.amazonaws.elasticloadbalancingv2#AvailabilityZoneNotSupportedException":
-            throw await de_AvailabilityZoneNotSupportedExceptionRes(parsedOutput, context);
-        case "DuplicateLoadBalancerName":
-        case "com.amazonaws.elasticloadbalancingv2#DuplicateLoadBalancerNameException":
-            throw await de_DuplicateLoadBalancerNameExceptionRes(parsedOutput, context);
-        case "DuplicateTagKeys":
-        case "com.amazonaws.elasticloadbalancingv2#DuplicateTagKeysException":
-            throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "InvalidScheme":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidSchemeException":
-            throw await de_InvalidSchemeExceptionRes(parsedOutput, context);
-        case "InvalidSecurityGroup":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidSecurityGroupException":
-            throw await de_InvalidSecurityGroupExceptionRes(parsedOutput, context);
-        case "InvalidSubnet":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidSubnetException":
-            throw await de_InvalidSubnetExceptionRes(parsedOutput, context);
-        case "OperationNotPermitted":
-        case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
-            throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
-        case "ResourceInUse":
-        case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-        case "SubnetNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#SubnetNotFoundException":
-            throw await de_SubnetNotFoundExceptionRes(parsedOutput, context);
-        case "TooManyLoadBalancers":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyLoadBalancersException":
-            throw await de_TooManyLoadBalancersExceptionRes(parsedOutput, context);
-        case "TooManyTags":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
-            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateRuleCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateRuleCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -739,1365 +518,454 @@ export const de_CreateRuleCommand = async (output, context) => {
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
-    };
-    return response;
-};
-const de_CreateRuleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "IncompatibleProtocols":
-        case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
-            throw await de_IncompatibleProtocolsExceptionRes(parsedOutput, context);
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "InvalidLoadBalancerAction":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
-            throw await de_InvalidLoadBalancerActionExceptionRes(parsedOutput, context);
-        case "ListenerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
-        case "PriorityInUse":
-        case "com.amazonaws.elasticloadbalancingv2#PriorityInUseException":
-            throw await de_PriorityInUseExceptionRes(parsedOutput, context);
-        case "TargetGroupAssociationLimit":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
-            throw await de_TargetGroupAssociationLimitExceptionRes(parsedOutput, context);
-        case "TargetGroupNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            throw await de_TargetGroupNotFoundExceptionRes(parsedOutput, context);
-        case "TooManyActions":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
-            throw await de_TooManyActionsExceptionRes(parsedOutput, context);
-        case "TooManyRegistrationsForTargetId":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
-            throw await de_TooManyRegistrationsForTargetIdExceptionRes(parsedOutput, context);
-        case "TooManyRules":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyRulesException":
-            throw await de_TooManyRulesExceptionRes(parsedOutput, context);
-        case "TooManyTags":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
-            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
-        case "TooManyTargetGroups":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyTargetGroupsException":
-            throw await de_TooManyTargetGroupsExceptionRes(parsedOutput, context);
-        case "TooManyTargets":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
-            throw await de_TooManyTargetsExceptionRes(parsedOutput, context);
-        case "TooManyUniqueTargetGroupsPerLoadBalancer":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
-            throw await de_TooManyUniqueTargetGroupsPerLoadBalancerExceptionRes(parsedOutput, context);
-        case "UnsupportedProtocol":
-        case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
-            throw await de_UnsupportedProtocolExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_CreateTargetGroupCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CreateTargetGroupCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_CreateTargetGroupOutput(data.CreateTargetGroupResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateTargetGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "DuplicateTargetGroupName":
-        case "com.amazonaws.elasticloadbalancingv2#DuplicateTargetGroupNameException":
-            throw await de_DuplicateTargetGroupNameExceptionRes(parsedOutput, context);
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "TooManyTags":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
-            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
-        case "TooManyTargetGroups":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyTargetGroupsException":
-            throw await de_TooManyTargetGroupsExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_CreateTrustStoreCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CreateTrustStoreCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_CreateTrustStoreOutput(data.CreateTrustStoreResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateTrustStoreCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CaCertificatesBundleNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#CaCertificatesBundleNotFoundException":
-            throw await de_CaCertificatesBundleNotFoundExceptionRes(parsedOutput, context);
-        case "DuplicateTagKeys":
-        case "com.amazonaws.elasticloadbalancingv2#DuplicateTagKeysException":
-            throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
-        case "DuplicateTrustStoreName":
-        case "com.amazonaws.elasticloadbalancingv2#DuplicateTrustStoreNameException":
-            throw await de_DuplicateTrustStoreNameExceptionRes(parsedOutput, context);
-        case "InvalidCaCertificatesBundle":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidCaCertificatesBundleException":
-            throw await de_InvalidCaCertificatesBundleExceptionRes(parsedOutput, context);
-        case "TooManyTags":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
-            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
-        case "TooManyTrustStores":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyTrustStoresException":
-            throw await de_TooManyTrustStoresExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteListenerCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DeleteListenerCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DeleteListenerOutput(data.DeleteListenerResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteListenerCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ListenerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
-        case "ResourceInUse":
-        case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(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);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DeleteLoadBalancerOutput(data.DeleteLoadBalancerResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteLoadBalancerCommandError = 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.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            throw await de_LoadBalancerNotFoundExceptionRes(parsedOutput, context);
-        case "OperationNotPermitted":
-        case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
-            throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
-        case "ResourceInUse":
-        case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteRuleCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DeleteRuleCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DeleteRuleOutput(data.DeleteRuleResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteRuleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "OperationNotPermitted":
-        case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
-            throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
-        case "RuleNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
-            throw await de_RuleNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteTargetGroupCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DeleteTargetGroupCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DeleteTargetGroupOutput(data.DeleteTargetGroupResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteTargetGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ResourceInUse":
-        case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteTrustStoreCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DeleteTrustStoreCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DeleteTrustStoreOutput(data.DeleteTrustStoreResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteTrustStoreCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "TrustStoreInUse":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreInUseException":
-            throw await de_TrustStoreInUseExceptionRes(parsedOutput, context);
-        case "TrustStoreNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotFoundException":
-            throw await de_TrustStoreNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
+    };
+    return response;
 };
-export const de_DeregisterTargetsCommand = async (output, context) => {
+export const de_CreateTargetGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeregisterTargetsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DeregisterTargetsOutput(data.DeregisterTargetsResult, context);
+    contents = de_CreateTargetGroupOutput(data.CreateTargetGroupResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DeregisterTargetsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidTarget":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidTargetException":
-            throw await de_InvalidTargetExceptionRes(parsedOutput, context);
-        case "TargetGroupNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            throw await de_TargetGroupNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeAccountLimitsCommand = async (output, context) => {
+export const de_CreateTrustStoreCommand = 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 = {};
-    contents = de_DescribeAccountLimitsOutput(data.DescribeAccountLimitsResult, context);
+    contents = de_CreateTrustStoreOutput(data.CreateTrustStoreResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     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_DescribeListenerCertificatesCommand = async (output, context) => {
+export const de_DeleteListenerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeListenerCertificatesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeListenerCertificatesOutput(data.DescribeListenerCertificatesResult, context);
+    contents = de_DeleteListenerOutput(data.DeleteListenerResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeListenerCertificatesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ListenerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeListenersCommand = async (output, context) => {
+export const de_DeleteLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeListenersCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeListenersOutput(data.DescribeListenersResult, context);
+    contents = de_DeleteLoadBalancerOutput(data.DeleteLoadBalancerResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeListenersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ListenerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            throw await de_LoadBalancerNotFoundExceptionRes(parsedOutput, context);
-        case "UnsupportedProtocol":
-        case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
-            throw await de_UnsupportedProtocolExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeLoadBalancerAttributesCommand = async (output, context) => {
+export const de_DeleteRuleCommand = 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 = {};
-    contents = de_DescribeLoadBalancerAttributesOutput(data.DescribeLoadBalancerAttributesResult, context);
+    contents = de_DeleteRuleOutput(data.DeleteRuleResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     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 "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            throw await de_LoadBalancerNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeLoadBalancersCommand = async (output, context) => {
+export const de_DeleteTargetGroupCommand = 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 = {};
-    contents = de_DescribeLoadBalancersOutput(data.DescribeLoadBalancersResult, context);
+    contents = de_DeleteTargetGroupOutput(data.DeleteTargetGroupResult, 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 "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            throw await de_LoadBalancerNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeRulesCommand = async (output, context) => {
+export const de_DeleteTrustStoreCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeRulesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeRulesOutput(data.DescribeRulesResult, context);
+    contents = de_DeleteTrustStoreOutput(data.DeleteTrustStoreResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeRulesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ListenerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
-        case "RuleNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
-            throw await de_RuleNotFoundExceptionRes(parsedOutput, context);
-        case "UnsupportedProtocol":
-        case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
-            throw await de_UnsupportedProtocolExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeSSLPoliciesCommand = async (output, context) => {
+export const de_DeregisterTargetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeSSLPoliciesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeSSLPoliciesOutput(data.DescribeSSLPoliciesResult, context);
+    contents = de_DeregisterTargetsOutput(data.DeregisterTargetsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeSSLPoliciesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "SSLPolicyNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#SSLPolicyNotFoundException":
-            throw await de_SSLPolicyNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeTagsCommand = async (output, context) => {
+export const de_DescribeAccountLimitsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeTagsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeTagsOutput(data.DescribeTagsResult, context);
+    contents = de_DescribeAccountLimitsOutput(data.DescribeAccountLimitsResult, 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 "ListenerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            throw await de_LoadBalancerNotFoundExceptionRes(parsedOutput, context);
-        case "RuleNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
-            throw await de_RuleNotFoundExceptionRes(parsedOutput, context);
-        case "TargetGroupNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            throw await de_TargetGroupNotFoundExceptionRes(parsedOutput, context);
-        case "TrustStoreNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotFoundException":
-            throw await de_TrustStoreNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
+export const de_DescribeListenerCertificatesCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeListenerCertificatesOutput(data.DescribeListenerCertificatesResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_DescribeTargetGroupAttributesCommand = async (output, context) => {
+export const de_DescribeListenersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeTargetGroupAttributesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeTargetGroupAttributesOutput(data.DescribeTargetGroupAttributesResult, context);
+    contents = de_DescribeListenersOutput(data.DescribeListenersResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeTargetGroupAttributesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "TargetGroupNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            throw await de_TargetGroupNotFoundExceptionRes(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_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeLoadBalancerAttributesOutput(data.DescribeLoadBalancerAttributesResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_DescribeTargetGroupsCommand = async (output, context) => {
+export const de_DescribeLoadBalancersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeTargetGroupsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeTargetGroupsOutput(data.DescribeTargetGroupsResult, context);
+    contents = de_DescribeLoadBalancersOutput(data.DescribeLoadBalancersResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeTargetGroupsCommandError = 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.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            throw await de_LoadBalancerNotFoundExceptionRes(parsedOutput, context);
-        case "TargetGroupNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            throw await de_TargetGroupNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeTargetHealthCommand = async (output, context) => {
+export const de_DescribeRulesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeTargetHealthCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeTargetHealthOutput(data.DescribeTargetHealthResult, context);
+    contents = de_DescribeRulesOutput(data.DescribeRulesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeTargetHealthCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "HealthUnavailable":
-        case "com.amazonaws.elasticloadbalancingv2#HealthUnavailableException":
-            throw await de_HealthUnavailableExceptionRes(parsedOutput, context);
-        case "InvalidTarget":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidTargetException":
-            throw await de_InvalidTargetExceptionRes(parsedOutput, context);
-        case "TargetGroupNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            throw await de_TargetGroupNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeTrustStoreAssociationsCommand = async (output, context) => {
+export const de_DescribeSSLPoliciesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeTrustStoreAssociationsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeTrustStoreAssociationsOutput(data.DescribeTrustStoreAssociationsResult, context);
+    contents = de_DescribeSSLPoliciesOutput(data.DescribeSSLPoliciesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeTrustStoreAssociationsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "TrustStoreNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotFoundException":
-            throw await de_TrustStoreNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeTrustStoreRevocationsCommand = async (output, context) => {
+export const de_DescribeTagsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeTrustStoreRevocationsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeTrustStoreRevocationsOutput(data.DescribeTrustStoreRevocationsResult, context);
+    contents = de_DescribeTagsOutput(data.DescribeTagsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeTrustStoreRevocationsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "RevocationIdNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#RevocationIdNotFoundException":
-            throw await de_RevocationIdNotFoundExceptionRes(parsedOutput, context);
-        case "TrustStoreNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotFoundException":
-            throw await de_TrustStoreNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeTrustStoresCommand = async (output, context) => {
+export const de_DescribeTargetGroupAttributesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeTrustStoresCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeTrustStoresOutput(data.DescribeTrustStoresResult, context);
+    contents = de_DescribeTargetGroupAttributesOutput(data.DescribeTargetGroupAttributesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeTrustStoresCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "TrustStoreNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotFoundException":
-            throw await de_TrustStoreNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_GetTrustStoreCaCertificatesBundleCommand = async (output, context) => {
+export const de_DescribeTargetGroupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetTrustStoreCaCertificatesBundleCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_GetTrustStoreCaCertificatesBundleOutput(data.GetTrustStoreCaCertificatesBundleResult, context);
+    contents = de_DescribeTargetGroupsOutput(data.DescribeTargetGroupsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_GetTrustStoreCaCertificatesBundleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "TrustStoreNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotFoundException":
-            throw await de_TrustStoreNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_GetTrustStoreRevocationContentCommand = async (output, context) => {
+export const de_DescribeTargetHealthCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetTrustStoreRevocationContentCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_GetTrustStoreRevocationContentOutput(data.GetTrustStoreRevocationContentResult, context);
+    contents = de_DescribeTargetHealthOutput(data.DescribeTargetHealthResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_GetTrustStoreRevocationContentCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "RevocationIdNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#RevocationIdNotFoundException":
-            throw await de_RevocationIdNotFoundExceptionRes(parsedOutput, context);
-        case "TrustStoreNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotFoundException":
-            throw await de_TrustStoreNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
+export const de_DescribeTrustStoreAssociationsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeTrustStoreAssociationsOutput(data.DescribeTrustStoreAssociationsResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_ModifyListenerCommand = async (output, context) => {
+export const de_DescribeTrustStoreRevocationsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ModifyListenerCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_ModifyListenerOutput(data.ModifyListenerResult, context);
+    contents = de_DescribeTrustStoreRevocationsOutput(data.DescribeTrustStoreRevocationsResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ModifyListenerCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ALPNPolicyNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#ALPNPolicyNotSupportedException":
-            throw await de_ALPNPolicyNotSupportedExceptionRes(parsedOutput, context);
-        case "CertificateNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#CertificateNotFoundException":
-            throw await de_CertificateNotFoundExceptionRes(parsedOutput, context);
-        case "DuplicateListener":
-        case "com.amazonaws.elasticloadbalancingv2#DuplicateListenerException":
-            throw await de_DuplicateListenerExceptionRes(parsedOutput, context);
-        case "IncompatibleProtocols":
-        case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
-            throw await de_IncompatibleProtocolsExceptionRes(parsedOutput, context);
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "InvalidLoadBalancerAction":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
-            throw await de_InvalidLoadBalancerActionExceptionRes(parsedOutput, context);
-        case "ListenerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
-        case "SSLPolicyNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#SSLPolicyNotFoundException":
-            throw await de_SSLPolicyNotFoundExceptionRes(parsedOutput, context);
-        case "TargetGroupAssociationLimit":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
-            throw await de_TargetGroupAssociationLimitExceptionRes(parsedOutput, context);
-        case "TargetGroupNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            throw await de_TargetGroupNotFoundExceptionRes(parsedOutput, context);
-        case "TooManyActions":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
-            throw await de_TooManyActionsExceptionRes(parsedOutput, context);
-        case "TooManyCertificates":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyCertificatesException":
-            throw await de_TooManyCertificatesExceptionRes(parsedOutput, context);
-        case "TooManyListeners":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyListenersException":
-            throw await de_TooManyListenersExceptionRes(parsedOutput, context);
-        case "TooManyRegistrationsForTargetId":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
-            throw await de_TooManyRegistrationsForTargetIdExceptionRes(parsedOutput, context);
-        case "TooManyTargets":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
-            throw await de_TooManyTargetsExceptionRes(parsedOutput, context);
-        case "TooManyUniqueTargetGroupsPerLoadBalancer":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
-            throw await de_TooManyUniqueTargetGroupsPerLoadBalancerExceptionRes(parsedOutput, context);
-        case "TrustStoreNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotFoundException":
-            throw await de_TrustStoreNotFoundExceptionRes(parsedOutput, context);
-        case "TrustStoreNotReady":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotReadyException":
-            throw await de_TrustStoreNotReadyExceptionRes(parsedOutput, context);
-        case "UnsupportedProtocol":
-        case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
-            throw await de_UnsupportedProtocolExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
+export const de_DescribeTrustStoresCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeTrustStoresOutput(data.DescribeTrustStoresResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_ModifyLoadBalancerAttributesCommand = async (output, context) => {
+export const de_GetTrustStoreCaCertificatesBundleCommand = 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 = {};
-    contents = de_ModifyLoadBalancerAttributesOutput(data.ModifyLoadBalancerAttributesResult, context);
+    contents = de_GetTrustStoreCaCertificatesBundleOutput(data.GetTrustStoreCaCertificatesBundleResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     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.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            throw await de_LoadBalancerNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_ModifyRuleCommand = async (output, context) => {
+export const de_GetTrustStoreRevocationContentCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ModifyRuleCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_ModifyRuleOutput(data.ModifyRuleResult, context);
+    contents = de_GetTrustStoreRevocationContentOutput(data.GetTrustStoreRevocationContentResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ModifyRuleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "IncompatibleProtocols":
-        case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
-            throw await de_IncompatibleProtocolsExceptionRes(parsedOutput, context);
-        case "InvalidLoadBalancerAction":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
-            throw await de_InvalidLoadBalancerActionExceptionRes(parsedOutput, context);
-        case "OperationNotPermitted":
-        case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
-            throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
-        case "RuleNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
-            throw await de_RuleNotFoundExceptionRes(parsedOutput, context);
-        case "TargetGroupAssociationLimit":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
-            throw await de_TargetGroupAssociationLimitExceptionRes(parsedOutput, context);
-        case "TargetGroupNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            throw await de_TargetGroupNotFoundExceptionRes(parsedOutput, context);
-        case "TooManyActions":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
-            throw await de_TooManyActionsExceptionRes(parsedOutput, context);
-        case "TooManyRegistrationsForTargetId":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
-            throw await de_TooManyRegistrationsForTargetIdExceptionRes(parsedOutput, context);
-        case "TooManyTargets":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
-            throw await de_TooManyTargetsExceptionRes(parsedOutput, context);
-        case "TooManyUniqueTargetGroupsPerLoadBalancer":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
-            throw await de_TooManyUniqueTargetGroupsPerLoadBalancerExceptionRes(parsedOutput, context);
-        case "UnsupportedProtocol":
-        case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
-            throw await de_UnsupportedProtocolExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_ModifyTargetGroupCommand = async (output, context) => {
+export const de_ModifyListenerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ModifyTargetGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_ModifyTargetGroupOutput(data.ModifyTargetGroupResult, context);
+    contents = de_ModifyListenerOutput(data.ModifyListenerResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ModifyTargetGroupCommandError = 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.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "TargetGroupNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            throw await de_TargetGroupNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_ModifyTargetGroupAttributesCommand = async (output, context) => {
+export const de_ModifyLoadBalancerAttributesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ModifyTargetGroupAttributesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_ModifyTargetGroupAttributesOutput(data.ModifyTargetGroupAttributesResult, context);
+    contents = de_ModifyLoadBalancerAttributesOutput(data.ModifyLoadBalancerAttributesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ModifyTargetGroupAttributesCommandError = 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.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "TargetGroupNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            throw await de_TargetGroupNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_ModifyTrustStoreCommand = async (output, context) => {
+export const de_ModifyRuleCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ModifyTrustStoreCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_ModifyTrustStoreOutput(data.ModifyTrustStoreResult, context);
+    contents = de_ModifyRuleOutput(data.ModifyRuleResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ModifyTrustStoreCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CaCertificatesBundleNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#CaCertificatesBundleNotFoundException":
-            throw await de_CaCertificatesBundleNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidCaCertificatesBundle":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidCaCertificatesBundleException":
-            throw await de_InvalidCaCertificatesBundleExceptionRes(parsedOutput, context);
-        case "TrustStoreNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotFoundException":
-            throw await de_TrustStoreNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_RegisterTargetsCommand = async (output, context) => {
+export const de_ModifyTargetGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RegisterTargetsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_RegisterTargetsOutput(data.RegisterTargetsResult, context);
+    contents = de_ModifyTargetGroupOutput(data.ModifyTargetGroupResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_RegisterTargetsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidTarget":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidTargetException":
-            throw await de_InvalidTargetExceptionRes(parsedOutput, context);
-        case "TargetGroupNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            throw await de_TargetGroupNotFoundExceptionRes(parsedOutput, context);
-        case "TooManyRegistrationsForTargetId":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
-            throw await de_TooManyRegistrationsForTargetIdExceptionRes(parsedOutput, context);
-        case "TooManyTargets":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
-            throw await de_TooManyTargetsExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_RemoveListenerCertificatesCommand = async (output, context) => {
+export const de_ModifyTargetGroupAttributesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RemoveListenerCertificatesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_RemoveListenerCertificatesOutput(data.RemoveListenerCertificatesResult, context);
+    contents = de_ModifyTargetGroupAttributesOutput(data.ModifyTargetGroupAttributesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_RemoveListenerCertificatesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ListenerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
-        case "OperationNotPermitted":
-        case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
-            throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_RemoveTagsCommand = async (output, context) => {
+export const de_ModifyTrustStoreCommand = 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 = {};
-    contents = de_RemoveTagsOutput(data.RemoveTagsResult, context);
+    contents = de_ModifyTrustStoreOutput(data.ModifyTrustStoreResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     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 "ListenerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            throw await de_LoadBalancerNotFoundExceptionRes(parsedOutput, context);
-        case "RuleNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
-            throw await de_RuleNotFoundExceptionRes(parsedOutput, context);
-        case "TargetGroupNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            throw await de_TargetGroupNotFoundExceptionRes(parsedOutput, context);
-        case "TooManyTags":
-        case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
-            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
-        case "TrustStoreNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotFoundException":
-            throw await de_TrustStoreNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
+export const de_RegisterTargetsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_RegisterTargetsOutput(data.RegisterTargetsResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_RemoveTrustStoreRevocationsCommand = async (output, context) => {
+export const de_RemoveListenerCertificatesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RemoveTrustStoreRevocationsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_RemoveTrustStoreRevocationsOutput(data.RemoveTrustStoreRevocationsResult, context);
+    contents = de_RemoveListenerCertificatesOutput(data.RemoveListenerCertificatesResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_RemoveTrustStoreRevocationsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const de_RemoveTagsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_RemoveTagsOutput(data.RemoveTagsResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "RevocationIdNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#RevocationIdNotFoundException":
-            throw await de_RevocationIdNotFoundExceptionRes(parsedOutput, context);
-        case "TrustStoreNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotFoundException":
-            throw await de_TrustStoreNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
+    return response;
+};
+export const de_RemoveTrustStoreRevocationsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_RemoveTrustStoreRevocationsOutput(data.RemoveTrustStoreRevocationsResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
 export const de_SetIpAddressTypeCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_SetIpAddressTypeCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2108,34 +976,9 @@ export const de_SetIpAddressTypeCommand = async (output, context) => {
     };
     return response;
 };
-const de_SetIpAddressTypeCommandError = 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.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "InvalidSubnet":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidSubnetException":
-            throw await de_InvalidSubnetExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            throw await de_LoadBalancerNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_SetRulePrioritiesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_SetRulePrioritiesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2146,34 +989,9 @@ export const de_SetRulePrioritiesCommand = async (output, context) => {
     };
     return response;
 };
-const de_SetRulePrioritiesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "OperationNotPermitted":
-        case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
-            throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
-        case "PriorityInUse":
-        case "com.amazonaws.elasticloadbalancingv2#PriorityInUseException":
-            throw await de_PriorityInUseExceptionRes(parsedOutput, context);
-        case "RuleNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
-            throw await de_RuleNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_SetSecurityGroupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_SetSecurityGroupsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2184,34 +1002,9 @@ export const de_SetSecurityGroupsCommand = async (output, context) => {
     };
     return response;
 };
-const de_SetSecurityGroupsCommandError = 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.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
-        case "InvalidSecurityGroup":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidSecurityGroupException":
-            throw await de_InvalidSecurityGroupExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            throw await de_LoadBalancerNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_SetSubnetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_SetSubnetsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2222,31 +1015,157 @@ export const de_SetSubnetsCommand = async (output, context) => {
     };
     return response;
 };
-const de_SetSubnetsCommandError = 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 "CertificateNotFound":
+        case "com.amazonaws.elasticloadbalancingv2#CertificateNotFoundException":
+            throw await de_CertificateNotFoundExceptionRes(parsedOutput, context);
+        case "ListenerNotFound":
+        case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
+            throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
+        case "TooManyCertificates":
+        case "com.amazonaws.elasticloadbalancingv2#TooManyCertificatesException":
+            throw await de_TooManyCertificatesExceptionRes(parsedOutput, context);
+        case "DuplicateTagKeys":
+        case "com.amazonaws.elasticloadbalancingv2#DuplicateTagKeysException":
+            throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
+        case "LoadBalancerNotFound":
+        case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
+            throw await de_LoadBalancerNotFoundExceptionRes(parsedOutput, context);
+        case "RuleNotFound":
+        case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
+            throw await de_RuleNotFoundExceptionRes(parsedOutput, context);
+        case "TargetGroupNotFound":
+        case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
+            throw await de_TargetGroupNotFoundExceptionRes(parsedOutput, context);
+        case "TooManyTags":
+        case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+        case "TrustStoreNotFound":
+        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotFoundException":
+            throw await de_TrustStoreNotFoundExceptionRes(parsedOutput, context);
+        case "InvalidRevocationContent":
+        case "com.amazonaws.elasticloadbalancingv2#InvalidRevocationContentException":
+            throw await de_InvalidRevocationContentExceptionRes(parsedOutput, context);
+        case "RevocationContentNotFound":
+        case "com.amazonaws.elasticloadbalancingv2#RevocationContentNotFoundException":
+            throw await de_RevocationContentNotFoundExceptionRes(parsedOutput, context);
+        case "TooManyTrustStoreRevocationEntries":
+        case "com.amazonaws.elasticloadbalancingv2#TooManyTrustStoreRevocationEntriesException":
+            throw await de_TooManyTrustStoreRevocationEntriesExceptionRes(parsedOutput, context);
+        case "ALPNPolicyNotFound":
+        case "com.amazonaws.elasticloadbalancingv2#ALPNPolicyNotSupportedException":
+            throw await de_ALPNPolicyNotSupportedExceptionRes(parsedOutput, context);
+        case "DuplicateListener":
+        case "com.amazonaws.elasticloadbalancingv2#DuplicateListenerException":
+            throw await de_DuplicateListenerExceptionRes(parsedOutput, context);
+        case "IncompatibleProtocols":
+        case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
+            throw await de_IncompatibleProtocolsExceptionRes(parsedOutput, context);
+        case "InvalidConfigurationRequest":
+        case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
+            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+        case "InvalidLoadBalancerAction":
+        case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
+            throw await de_InvalidLoadBalancerActionExceptionRes(parsedOutput, context);
+        case "SSLPolicyNotFound":
+        case "com.amazonaws.elasticloadbalancingv2#SSLPolicyNotFoundException":
+            throw await de_SSLPolicyNotFoundExceptionRes(parsedOutput, context);
+        case "TargetGroupAssociationLimit":
+        case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
+            throw await de_TargetGroupAssociationLimitExceptionRes(parsedOutput, context);
+        case "TooManyActions":
+        case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
+            throw await de_TooManyActionsExceptionRes(parsedOutput, context);
+        case "TooManyListeners":
+        case "com.amazonaws.elasticloadbalancingv2#TooManyListenersException":
+            throw await de_TooManyListenersExceptionRes(parsedOutput, context);
+        case "TooManyRegistrationsForTargetId":
+        case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
+            throw await de_TooManyRegistrationsForTargetIdExceptionRes(parsedOutput, context);
+        case "TooManyTargets":
+        case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
+            throw await de_TooManyTargetsExceptionRes(parsedOutput, context);
+        case "TooManyUniqueTargetGroupsPerLoadBalancer":
+        case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
+            throw await de_TooManyUniqueTargetGroupsPerLoadBalancerExceptionRes(parsedOutput, context);
+        case "TrustStoreNotReady":
+        case "com.amazonaws.elasticloadbalancingv2#TrustStoreNotReadyException":
+            throw await de_TrustStoreNotReadyExceptionRes(parsedOutput, context);
+        case "UnsupportedProtocol":
+        case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
+            throw await de_UnsupportedProtocolExceptionRes(parsedOutput, context);
         case "AllocationIdNotFound":
         case "com.amazonaws.elasticloadbalancingv2#AllocationIdNotFoundException":
             throw await de_AllocationIdNotFoundExceptionRes(parsedOutput, context);
         case "AvailabilityZoneNotSupported":
         case "com.amazonaws.elasticloadbalancingv2#AvailabilityZoneNotSupportedException":
             throw await de_AvailabilityZoneNotSupportedExceptionRes(parsedOutput, context);
-        case "InvalidConfigurationRequest":
-        case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+        case "DuplicateLoadBalancerName":
+        case "com.amazonaws.elasticloadbalancingv2#DuplicateLoadBalancerNameException":
+            throw await de_DuplicateLoadBalancerNameExceptionRes(parsedOutput, context);
+        case "InvalidScheme":
+        case "com.amazonaws.elasticloadbalancingv2#InvalidSchemeException":
+            throw await de_InvalidSchemeExceptionRes(parsedOutput, context);
+        case "InvalidSecurityGroup":
+        case "com.amazonaws.elasticloadbalancingv2#InvalidSecurityGroupException":
+            throw await de_InvalidSecurityGroupExceptionRes(parsedOutput, context);
         case "InvalidSubnet":
         case "com.amazonaws.elasticloadbalancingv2#InvalidSubnetException":
             throw await de_InvalidSubnetExceptionRes(parsedOutput, context);
-        case "LoadBalancerNotFound":
-        case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            throw await de_LoadBalancerNotFoundExceptionRes(parsedOutput, context);
+        case "OperationNotPermitted":
+        case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
+            throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
+        case "ResourceInUse":
+        case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "SubnetNotFound":
         case "com.amazonaws.elasticloadbalancingv2#SubnetNotFoundException":
             throw await de_SubnetNotFoundExceptionRes(parsedOutput, context);
+        case "TooManyLoadBalancers":
+        case "com.amazonaws.elasticloadbalancingv2#TooManyLoadBalancersException":
+            throw await de_TooManyLoadBalancersExceptionRes(parsedOutput, context);
+        case "PriorityInUse":
+        case "com.amazonaws.elasticloadbalancingv2#PriorityInUseException":
+            throw await de_PriorityInUseExceptionRes(parsedOutput, context);
+        case "TooManyRules":
+        case "com.amazonaws.elasticloadbalancingv2#TooManyRulesException":
+            throw await de_TooManyRulesExceptionRes(parsedOutput, context);
+        case "TooManyTargetGroups":
+        case "com.amazonaws.elasticloadbalancingv2#TooManyTargetGroupsException":
+            throw await de_TooManyTargetGroupsExceptionRes(parsedOutput, context);
+        case "DuplicateTargetGroupName":
+        case "com.amazonaws.elasticloadbalancingv2#DuplicateTargetGroupNameException":
+            throw await de_DuplicateTargetGroupNameExceptionRes(parsedOutput, context);
+        case "CaCertificatesBundleNotFound":
+        case "com.amazonaws.elasticloadbalancingv2#CaCertificatesBundleNotFoundException":
+            throw await de_CaCertificatesBundleNotFoundExceptionRes(parsedOutput, context);
+        case "DuplicateTrustStoreName":
+        case "com.amazonaws.elasticloadbalancingv2#DuplicateTrustStoreNameException":
+            throw await de_DuplicateTrustStoreNameExceptionRes(parsedOutput, context);
+        case "InvalidCaCertificatesBundle":
+        case "com.amazonaws.elasticloadbalancingv2#InvalidCaCertificatesBundleException":
+            throw await de_InvalidCaCertificatesBundleExceptionRes(parsedOutput, context);
+        case "TooManyTrustStores":
+        case "com.amazonaws.elasticloadbalancingv2#TooManyTrustStoresException":
+            throw await de_TooManyTrustStoresExceptionRes(parsedOutput, context);
+        case "TrustStoreInUse":
+        case "com.amazonaws.elasticloadbalancingv2#TrustStoreInUseException":
+            throw await de_TrustStoreInUseExceptionRes(parsedOutput, context);
+        case "InvalidTarget":
+        case "com.amazonaws.elasticloadbalancingv2#InvalidTargetException":
+            throw await de_InvalidTargetExceptionRes(parsedOutput, context);
+        case "HealthUnavailable":
+        case "com.amazonaws.elasticloadbalancingv2#HealthUnavailableException":
+            throw await de_HealthUnavailableExceptionRes(parsedOutput, context);
+        case "RevocationIdNotFound":
+        case "com.amazonaws.elasticloadbalancingv2#RevocationIdNotFoundException":
+            throw await de_RevocationIdNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({