@aws-sdk/client-elastic-load-balancing-v2 3.51.0 → 3.54.0

package/dist-cjs/protocols/Aws_query.js

@@ -6,6 +6,8 @@ const protocol_http_1 = require("@aws-sdk/protocol-http");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const entities_1 = require("entities");
 const fast_xml_parser_1 = require("fast-xml-parser");
+const ElasticLoadBalancingV2ServiceException_1 = require("../models/ElasticLoadBalancingV2ServiceException");
+const models_0_1 = require("../models/models_0");
 const serializeAws_queryAddListenerCertificatesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -473,43 +475,22 @@ const deserializeAws_queryAddListenerCertificatesCommandError = async (output, c
     switch (errorCode) {
         case "CertificateNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#CertificateNotFoundException":
-            response = {
-                ...(await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context);
         case "ListenerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
         case "TooManyCertificatesException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyCertificatesException":
-            response = {
-                ...(await deserializeAws_queryTooManyCertificatesExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyCertificatesExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryAddTagsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -536,67 +517,31 @@ const deserializeAws_queryAddTagsCommandError = async (output, context) => {
     switch (errorCode) {
         case "DuplicateTagKeysException":
         case "com.amazonaws.elasticloadbalancingv2#DuplicateTagKeysException":
-            response = {
-                ...(await deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context);
         case "ListenerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
         case "LoadBalancerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
         case "RuleNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
-            response = {
-                ...(await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
         case "TargetGroupNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
-            response = {
-                ...(await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryCreateListenerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -623,163 +568,67 @@ const deserializeAws_queryCreateListenerCommandError = async (output, context) =
     switch (errorCode) {
         case "ALPNPolicyNotSupportedException":
         case "com.amazonaws.elasticloadbalancingv2#ALPNPolicyNotSupportedException":
-            response = {
-                ...(await deserializeAws_queryALPNPolicyNotSupportedExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryALPNPolicyNotSupportedExceptionResponse(parsedOutput, context);
         case "CertificateNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#CertificateNotFoundException":
-            response = {
-                ...(await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context);
         case "DuplicateListenerException":
         case "com.amazonaws.elasticloadbalancingv2#DuplicateListenerException":
-            response = {
-                ...(await deserializeAws_queryDuplicateListenerExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryDuplicateListenerExceptionResponse(parsedOutput, context);
         case "IncompatibleProtocolsException":
         case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
-            response = {
-                ...(await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "InvalidLoadBalancerActionException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
-            response = {
-                ...(await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context);
         case "LoadBalancerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
         case "SSLPolicyNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#SSLPolicyNotFoundException":
-            response = {
-                ...(await deserializeAws_querySSLPolicyNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_querySSLPolicyNotFoundExceptionResponse(parsedOutput, context);
         case "TargetGroupAssociationLimitException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context);
         case "TargetGroupNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
         case "TooManyActionsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
-            response = {
-                ...(await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context);
         case "TooManyCertificatesException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyCertificatesException":
-            response = {
-                ...(await deserializeAws_queryTooManyCertificatesExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyCertificatesExceptionResponse(parsedOutput, context);
         case "TooManyListenersException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyListenersException":
-            response = {
-                ...(await deserializeAws_queryTooManyListenersExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyListenersExceptionResponse(parsedOutput, context);
         case "TooManyRegistrationsForTargetIdException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
-            response = {
-                ...(await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
-            response = {
-                ...(await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
         case "TooManyTargetsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
-            response = {
-                ...(await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context);
         case "TooManyUniqueTargetGroupsPerLoadBalancerException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
-            response = {
-                ...(await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context);
         case "UnsupportedProtocolException":
         case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
-            response = {
-                ...(await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryCreateLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -806,123 +655,52 @@ const deserializeAws_queryCreateLoadBalancerCommandError = async (output, contex
     switch (errorCode) {
         case "AllocationIdNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#AllocationIdNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAllocationIdNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAllocationIdNotFoundExceptionResponse(parsedOutput, context);
         case "AvailabilityZoneNotSupportedException":
         case "com.amazonaws.elasticloadbalancingv2#AvailabilityZoneNotSupportedException":
-            response = {
-                ...(await deserializeAws_queryAvailabilityZoneNotSupportedExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAvailabilityZoneNotSupportedExceptionResponse(parsedOutput, context);
         case "DuplicateLoadBalancerNameException":
         case "com.amazonaws.elasticloadbalancingv2#DuplicateLoadBalancerNameException":
-            response = {
-                ...(await deserializeAws_queryDuplicateLoadBalancerNameExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryDuplicateLoadBalancerNameExceptionResponse(parsedOutput, context);
         case "DuplicateTagKeysException":
         case "com.amazonaws.elasticloadbalancingv2#DuplicateTagKeysException":
-            response = {
-                ...(await deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "InvalidSchemeException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidSchemeException":
-            response = {
-                ...(await deserializeAws_queryInvalidSchemeExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidSchemeExceptionResponse(parsedOutput, context);
         case "InvalidSecurityGroupException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidSecurityGroupException":
-            response = {
-                ...(await deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context);
         case "InvalidSubnetException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidSubnetException":
-            response = {
-                ...(await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context);
         case "OperationNotPermittedException":
         case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
-            response = {
-                ...(await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
-            response = {
-                ...(await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context);
         case "SubnetNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#SubnetNotFoundException":
-            response = {
-                ...(await deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context);
         case "TooManyLoadBalancersException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyLoadBalancersException":
-            response = {
-                ...(await deserializeAws_queryTooManyLoadBalancersExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyLoadBalancersExceptionResponse(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
-            response = {
-                ...(await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryCreateRuleCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -949,139 +727,58 @@ const deserializeAws_queryCreateRuleCommandError = async (output, context) => {
     switch (errorCode) {
         case "IncompatibleProtocolsException":
         case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
-            response = {
-                ...(await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "InvalidLoadBalancerActionException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
-            response = {
-                ...(await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context);
         case "ListenerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
         case "PriorityInUseException":
         case "com.amazonaws.elasticloadbalancingv2#PriorityInUseException":
-            response = {
-                ...(await deserializeAws_queryPriorityInUseExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryPriorityInUseExceptionResponse(parsedOutput, context);
         case "TargetGroupAssociationLimitException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context);
         case "TargetGroupNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
         case "TooManyActionsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
-            response = {
-                ...(await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context);
         case "TooManyRegistrationsForTargetIdException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
-            response = {
-                ...(await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context);
         case "TooManyRulesException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyRulesException":
-            response = {
-                ...(await deserializeAws_queryTooManyRulesExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyRulesExceptionResponse(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
-            response = {
-                ...(await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
         case "TooManyTargetGroupsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyTargetGroupsException":
-            response = {
-                ...(await deserializeAws_queryTooManyTargetGroupsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyTargetGroupsExceptionResponse(parsedOutput, context);
         case "TooManyTargetsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
-            response = {
-                ...(await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context);
         case "TooManyUniqueTargetGroupsPerLoadBalancerException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
-            response = {
-                ...(await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context);
         case "UnsupportedProtocolException":
         case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
-            response = {
-                ...(await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryCreateTargetGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1108,51 +805,25 @@ const deserializeAws_queryCreateTargetGroupCommandError = async (output, context
     switch (errorCode) {
         case "DuplicateTargetGroupNameException":
         case "com.amazonaws.elasticloadbalancingv2#DuplicateTargetGroupNameException":
-            response = {
-                ...(await deserializeAws_queryDuplicateTargetGroupNameExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryDuplicateTargetGroupNameExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
-            response = {
-                ...(await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
         case "TooManyTargetGroupsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyTargetGroupsException":
-            response = {
-                ...(await deserializeAws_queryTooManyTargetGroupsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyTargetGroupsExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryDeleteListenerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1179,35 +850,19 @@ const deserializeAws_queryDeleteListenerCommandError = async (output, context) =
     switch (errorCode) {
         case "ListenerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
-            response = {
-                ...(await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryDeleteLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1234,43 +889,22 @@ const deserializeAws_queryDeleteLoadBalancerCommandError = async (output, contex
     switch (errorCode) {
         case "LoadBalancerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
         case "OperationNotPermittedException":
         case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
-            response = {
-                ...(await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
-            response = {
-                ...(await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryDeleteRuleCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1297,35 +931,19 @@ const deserializeAws_queryDeleteRuleCommandError = async (output, context) => {
     switch (errorCode) {
         case "OperationNotPermittedException":
         case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
-            response = {
-                ...(await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
         case "RuleNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
-            response = {
-                ...(await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryDeleteTargetGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1352,27 +970,16 @@ const deserializeAws_queryDeleteTargetGroupCommandError = async (output, context
     switch (errorCode) {
         case "ResourceInUseException":
         case "com.amazonaws.elasticloadbalancingv2#ResourceInUseException":
-            response = {
-                ...(await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryResourceInUseExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryDeregisterTargetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1399,35 +1006,19 @@ const deserializeAws_queryDeregisterTargetsCommandError = async (output, context
     switch (errorCode) {
         case "InvalidTargetException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidTargetException":
-            response = {
-                ...(await deserializeAws_queryInvalidTargetExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidTargetExceptionResponse(parsedOutput, context);
         case "TargetGroupNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryDescribeAccountLimitsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1454,19 +1045,13 @@ const deserializeAws_queryDescribeAccountLimitsCommandError = async (output, con
     switch (errorCode) {
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryDescribeListenerCertificatesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1493,27 +1078,16 @@ const deserializeAws_queryDescribeListenerCertificatesCommandError = async (outp
     switch (errorCode) {
         case "ListenerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryDescribeListenersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1540,43 +1114,22 @@ const deserializeAws_queryDescribeListenersCommandError = async (output, context
     switch (errorCode) {
         case "ListenerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
         case "LoadBalancerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
         case "UnsupportedProtocolException":
         case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
-            response = {
-                ...(await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryDescribeLoadBalancerAttributesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1603,27 +1156,16 @@ const deserializeAws_queryDescribeLoadBalancerAttributesCommandError = async (ou
     switch (errorCode) {
         case "LoadBalancerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryDescribeLoadBalancersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1650,27 +1192,16 @@ const deserializeAws_queryDescribeLoadBalancersCommandError = async (output, con
     switch (errorCode) {
         case "LoadBalancerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryDescribeRulesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1697,43 +1228,22 @@ const deserializeAws_queryDescribeRulesCommandError = async (output, context) =>
     switch (errorCode) {
         case "ListenerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
         case "RuleNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
-            response = {
-                ...(await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
         case "UnsupportedProtocolException":
         case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
-            response = {
-                ...(await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryDescribeSSLPoliciesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1760,27 +1270,16 @@ const deserializeAws_queryDescribeSSLPoliciesCommandError = async (output, conte
     switch (errorCode) {
         case "SSLPolicyNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#SSLPolicyNotFoundException":
-            response = {
-                ...(await deserializeAws_querySSLPolicyNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_querySSLPolicyNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryDescribeTagsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1807,51 +1306,25 @@ const deserializeAws_queryDescribeTagsCommandError = async (output, context) =>
     switch (errorCode) {
         case "ListenerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
         case "LoadBalancerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
         case "RuleNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
-            response = {
-                ...(await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
         case "TargetGroupNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryDescribeTargetGroupAttributesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1878,27 +1351,16 @@ const deserializeAws_queryDescribeTargetGroupAttributesCommandError = async (out
     switch (errorCode) {
         case "TargetGroupNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryDescribeTargetGroupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1925,35 +1387,19 @@ const deserializeAws_queryDescribeTargetGroupsCommandError = async (output, cont
     switch (errorCode) {
         case "LoadBalancerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
         case "TargetGroupNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryDescribeTargetHealthCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1980,43 +1426,22 @@ const deserializeAws_queryDescribeTargetHealthCommandError = async (output, cont
     switch (errorCode) {
         case "HealthUnavailableException":
         case "com.amazonaws.elasticloadbalancingv2#HealthUnavailableException":
-            response = {
-                ...(await deserializeAws_queryHealthUnavailableExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryHealthUnavailableExceptionResponse(parsedOutput, context);
         case "InvalidTargetException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidTargetException":
-            response = {
-                ...(await deserializeAws_queryInvalidTargetExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidTargetExceptionResponse(parsedOutput, context);
         case "TargetGroupNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryModifyListenerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -2043,155 +1468,64 @@ const deserializeAws_queryModifyListenerCommandError = async (output, context) =
     switch (errorCode) {
         case "ALPNPolicyNotSupportedException":
         case "com.amazonaws.elasticloadbalancingv2#ALPNPolicyNotSupportedException":
-            response = {
-                ...(await deserializeAws_queryALPNPolicyNotSupportedExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryALPNPolicyNotSupportedExceptionResponse(parsedOutput, context);
         case "CertificateNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#CertificateNotFoundException":
-            response = {
-                ...(await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context);
         case "DuplicateListenerException":
         case "com.amazonaws.elasticloadbalancingv2#DuplicateListenerException":
-            response = {
-                ...(await deserializeAws_queryDuplicateListenerExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryDuplicateListenerExceptionResponse(parsedOutput, context);
         case "IncompatibleProtocolsException":
         case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
-            response = {
-                ...(await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "InvalidLoadBalancerActionException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
-            response = {
-                ...(await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context);
         case "ListenerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
         case "SSLPolicyNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#SSLPolicyNotFoundException":
-            response = {
-                ...(await deserializeAws_querySSLPolicyNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_querySSLPolicyNotFoundExceptionResponse(parsedOutput, context);
         case "TargetGroupAssociationLimitException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context);
         case "TargetGroupNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
         case "TooManyActionsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
-            response = {
-                ...(await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context);
         case "TooManyCertificatesException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyCertificatesException":
-            response = {
-                ...(await deserializeAws_queryTooManyCertificatesExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyCertificatesExceptionResponse(parsedOutput, context);
         case "TooManyListenersException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyListenersException":
-            response = {
-                ...(await deserializeAws_queryTooManyListenersExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyListenersExceptionResponse(parsedOutput, context);
         case "TooManyRegistrationsForTargetIdException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
-            response = {
-                ...(await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context);
         case "TooManyTargetsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
-            response = {
-                ...(await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context);
         case "TooManyUniqueTargetGroupsPerLoadBalancerException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
-            response = {
-                ...(await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context);
         case "UnsupportedProtocolException":
         case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
-            response = {
-                ...(await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryModifyLoadBalancerAttributesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -2218,35 +1552,19 @@ const deserializeAws_queryModifyLoadBalancerAttributesCommandError = async (outp
     switch (errorCode) {
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "LoadBalancerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryModifyRuleCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -2273,107 +1591,46 @@ const deserializeAws_queryModifyRuleCommandError = async (output, context) => {
     switch (errorCode) {
         case "IncompatibleProtocolsException":
         case "com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException":
-            response = {
-                ...(await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryIncompatibleProtocolsExceptionResponse(parsedOutput, context);
         case "InvalidLoadBalancerActionException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException":
-            response = {
-                ...(await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidLoadBalancerActionExceptionResponse(parsedOutput, context);
         case "OperationNotPermittedException":
         case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
-            response = {
-                ...(await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
         case "RuleNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
-            response = {
-                ...(await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
         case "TargetGroupAssociationLimitException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupAssociationLimitExceptionResponse(parsedOutput, context);
         case "TargetGroupNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
         case "TooManyActionsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyActionsException":
-            response = {
-                ...(await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyActionsExceptionResponse(parsedOutput, context);
         case "TooManyRegistrationsForTargetIdException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
-            response = {
-                ...(await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context);
         case "TooManyTargetsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
-            response = {
-                ...(await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context);
         case "TooManyUniqueTargetGroupsPerLoadBalancerException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException":
-            response = {
-                ...(await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse(parsedOutput, context);
         case "UnsupportedProtocolException":
         case "com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException":
-            response = {
-                ...(await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryModifyTargetGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -2400,35 +1657,19 @@ const deserializeAws_queryModifyTargetGroupCommandError = async (output, context
     switch (errorCode) {
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "TargetGroupNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryModifyTargetGroupAttributesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -2455,35 +1696,19 @@ const deserializeAws_queryModifyTargetGroupAttributesCommandError = async (outpu
     switch (errorCode) {
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "TargetGroupNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryRegisterTargetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -2510,51 +1735,25 @@ const deserializeAws_queryRegisterTargetsCommandError = async (output, context)
     switch (errorCode) {
         case "InvalidTargetException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidTargetException":
-            response = {
-                ...(await deserializeAws_queryInvalidTargetExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidTargetExceptionResponse(parsedOutput, context);
         case "TargetGroupNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
         case "TooManyRegistrationsForTargetIdException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException":
-            response = {
-                ...(await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse(parsedOutput, context);
         case "TooManyTargetsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyTargetsException":
-            response = {
-                ...(await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyTargetsExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryRemoveListenerCertificatesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -2581,35 +1780,19 @@ const deserializeAws_queryRemoveListenerCertificatesCommandError = async (output
     switch (errorCode) {
         case "ListenerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
         case "OperationNotPermittedException":
         case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
-            response = {
-                ...(await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryRemoveTagsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -2636,59 +1819,28 @@ const deserializeAws_queryRemoveTagsCommandError = async (output, context) => {
     switch (errorCode) {
         case "ListenerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
         case "LoadBalancerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
         case "RuleNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
-            response = {
-                ...(await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
         case "TargetGroupNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException":
-            response = {
-                ...(await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTargetGroupNotFoundExceptionResponse(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.elasticloadbalancingv2#TooManyTagsException":
-            response = {
-                ...(await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_querySetIpAddressTypeCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -2715,43 +1867,22 @@ const deserializeAws_querySetIpAddressTypeCommandError = async (output, context)
     switch (errorCode) {
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "InvalidSubnetException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidSubnetException":
-            response = {
-                ...(await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context);
         case "LoadBalancerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_querySetRulePrioritiesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -2778,43 +1909,22 @@ const deserializeAws_querySetRulePrioritiesCommandError = async (output, context
     switch (errorCode) {
         case "OperationNotPermittedException":
         case "com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException":
-            response = {
-                ...(await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
         case "PriorityInUseException":
         case "com.amazonaws.elasticloadbalancingv2#PriorityInUseException":
-            response = {
-                ...(await deserializeAws_queryPriorityInUseExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryPriorityInUseExceptionResponse(parsedOutput, context);
         case "RuleNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#RuleNotFoundException":
-            response = {
-                ...(await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryRuleNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_querySetSecurityGroupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -2841,43 +1951,22 @@ const deserializeAws_querySetSecurityGroupsCommandError = async (output, context
     switch (errorCode) {
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "InvalidSecurityGroupException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidSecurityGroupException":
-            response = {
-                ...(await deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context);
         case "LoadBalancerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_querySetSubnetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -2904,474 +1993,364 @@ const deserializeAws_querySetSubnetsCommandError = async (output, context) => {
     switch (errorCode) {
         case "AllocationIdNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#AllocationIdNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAllocationIdNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAllocationIdNotFoundExceptionResponse(parsedOutput, context);
         case "AvailabilityZoneNotSupportedException":
         case "com.amazonaws.elasticloadbalancingv2#AvailabilityZoneNotSupportedException":
-            response = {
-                ...(await deserializeAws_queryAvailabilityZoneNotSupportedExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAvailabilityZoneNotSupportedExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "InvalidSubnetException":
         case "com.amazonaws.elasticloadbalancingv2#InvalidSubnetException":
-            response = {
-                ...(await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context);
         case "LoadBalancerNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryLoadBalancerNotFoundExceptionResponse(parsedOutput, context);
         case "SubnetNotFoundException":
         case "com.amazonaws.elasticloadbalancingv2#SubnetNotFoundException":
-            response = {
-                ...(await deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
-            response = {
-                ...parsedBody.Error,
-                name: `${errorCode}`,
-                message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
+            response = new ElasticLoadBalancingV2ServiceException_1.ElasticLoadBalancingV2ServiceException({
+                name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
                 $fault: "client",
                 $metadata: deserializeMetadata(output),
-            };
+            });
+            throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
     }
-    const message = response.message || response.Message || errorCode;
-    response.message = message;
-    delete response.Message;
-    return Promise.reject(Object.assign(new Error(message), response));
 };
 const deserializeAws_queryAllocationIdNotFoundExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryAllocationIdNotFoundException(body.Error, context);
-    const contents = {
-        name: "AllocationIdNotFoundException",
-        $fault: "client",
+    const exception = new models_0_1.AllocationIdNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryALPNPolicyNotSupportedExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryALPNPolicyNotSupportedException(body.Error, context);
-    const contents = {
-        name: "ALPNPolicyNotSupportedException",
-        $fault: "client",
+    const exception = new models_0_1.ALPNPolicyNotSupportedException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryAvailabilityZoneNotSupportedExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryAvailabilityZoneNotSupportedException(body.Error, context);
-    const contents = {
-        name: "AvailabilityZoneNotSupportedException",
-        $fault: "client",
+    const exception = new models_0_1.AvailabilityZoneNotSupportedException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryCertificateNotFoundExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryCertificateNotFoundException(body.Error, context);
-    const contents = {
-        name: "CertificateNotFoundException",
-        $fault: "client",
+    const exception = new models_0_1.CertificateNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryDuplicateListenerExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryDuplicateListenerException(body.Error, context);
-    const contents = {
-        name: "DuplicateListenerException",
-        $fault: "client",
+    const exception = new models_0_1.DuplicateListenerException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryDuplicateLoadBalancerNameExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryDuplicateLoadBalancerNameException(body.Error, context);
-    const contents = {
-        name: "DuplicateLoadBalancerNameException",
-        $fault: "client",
+    const exception = new models_0_1.DuplicateLoadBalancerNameException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryDuplicateTagKeysExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryDuplicateTagKeysException(body.Error, context);
-    const contents = {
-        name: "DuplicateTagKeysException",
-        $fault: "client",
+    const exception = new models_0_1.DuplicateTagKeysException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryDuplicateTargetGroupNameExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryDuplicateTargetGroupNameException(body.Error, context);
-    const contents = {
-        name: "DuplicateTargetGroupNameException",
-        $fault: "client",
+    const exception = new models_0_1.DuplicateTargetGroupNameException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryHealthUnavailableExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryHealthUnavailableException(body.Error, context);
-    const contents = {
-        name: "HealthUnavailableException",
-        $fault: "server",
+    const exception = new models_0_1.HealthUnavailableException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryIncompatibleProtocolsExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryIncompatibleProtocolsException(body.Error, context);
-    const contents = {
-        name: "IncompatibleProtocolsException",
-        $fault: "client",
+    const exception = new models_0_1.IncompatibleProtocolsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryInvalidConfigurationRequestExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryInvalidConfigurationRequestException(body.Error, context);
-    const contents = {
-        name: "InvalidConfigurationRequestException",
-        $fault: "client",
+    const exception = new models_0_1.InvalidConfigurationRequestException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryInvalidLoadBalancerActionExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryInvalidLoadBalancerActionException(body.Error, context);
-    const contents = {
-        name: "InvalidLoadBalancerActionException",
-        $fault: "client",
+    const exception = new models_0_1.InvalidLoadBalancerActionException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryInvalidSchemeExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryInvalidSchemeException(body.Error, context);
-    const contents = {
-        name: "InvalidSchemeException",
-        $fault: "client",
+    const exception = new models_0_1.InvalidSchemeException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryInvalidSecurityGroupExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryInvalidSecurityGroupException(body.Error, context);
-    const contents = {
-        name: "InvalidSecurityGroupException",
-        $fault: "client",
+    const exception = new models_0_1.InvalidSecurityGroupException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryInvalidSubnetExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryInvalidSubnetException(body.Error, context);
-    const contents = {
-        name: "InvalidSubnetException",
-        $fault: "client",
+    const exception = new models_0_1.InvalidSubnetException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryInvalidTargetExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryInvalidTargetException(body.Error, context);
-    const contents = {
-        name: "InvalidTargetException",
-        $fault: "client",
+    const exception = new models_0_1.InvalidTargetException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryListenerNotFoundExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryListenerNotFoundException(body.Error, context);
-    const contents = {
-        name: "ListenerNotFoundException",
-        $fault: "client",
+    const exception = new models_0_1.ListenerNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryLoadBalancerNotFoundExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryLoadBalancerNotFoundException(body.Error, context);
-    const contents = {
-        name: "LoadBalancerNotFoundException",
-        $fault: "client",
+    const exception = new models_0_1.LoadBalancerNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryOperationNotPermittedExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryOperationNotPermittedException(body.Error, context);
-    const contents = {
-        name: "OperationNotPermittedException",
-        $fault: "client",
+    const exception = new models_0_1.OperationNotPermittedException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryPriorityInUseExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryPriorityInUseException(body.Error, context);
-    const contents = {
-        name: "PriorityInUseException",
-        $fault: "client",
+    const exception = new models_0_1.PriorityInUseException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryResourceInUseExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryResourceInUseException(body.Error, context);
-    const contents = {
-        name: "ResourceInUseException",
-        $fault: "client",
+    const exception = new models_0_1.ResourceInUseException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryRuleNotFoundExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryRuleNotFoundException(body.Error, context);
-    const contents = {
-        name: "RuleNotFoundException",
-        $fault: "client",
+    const exception = new models_0_1.RuleNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_querySSLPolicyNotFoundExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_querySSLPolicyNotFoundException(body.Error, context);
-    const contents = {
-        name: "SSLPolicyNotFoundException",
-        $fault: "client",
+    const exception = new models_0_1.SSLPolicyNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_querySubnetNotFoundExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_querySubnetNotFoundException(body.Error, context);
-    const contents = {
-        name: "SubnetNotFoundException",
-        $fault: "client",
+    const exception = new models_0_1.SubnetNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryTargetGroupAssociationLimitExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryTargetGroupAssociationLimitException(body.Error, context);
-    const contents = {
-        name: "TargetGroupAssociationLimitException",
-        $fault: "client",
+    const exception = new models_0_1.TargetGroupAssociationLimitException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryTargetGroupNotFoundExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryTargetGroupNotFoundException(body.Error, context);
-    const contents = {
-        name: "TargetGroupNotFoundException",
-        $fault: "client",
+    const exception = new models_0_1.TargetGroupNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryTooManyActionsExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryTooManyActionsException(body.Error, context);
-    const contents = {
-        name: "TooManyActionsException",
-        $fault: "client",
+    const exception = new models_0_1.TooManyActionsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryTooManyCertificatesExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryTooManyCertificatesException(body.Error, context);
-    const contents = {
-        name: "TooManyCertificatesException",
-        $fault: "client",
+    const exception = new models_0_1.TooManyCertificatesException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryTooManyListenersExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryTooManyListenersException(body.Error, context);
-    const contents = {
-        name: "TooManyListenersException",
-        $fault: "client",
+    const exception = new models_0_1.TooManyListenersException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryTooManyLoadBalancersExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryTooManyLoadBalancersException(body.Error, context);
-    const contents = {
-        name: "TooManyLoadBalancersException",
-        $fault: "client",
+    const exception = new models_0_1.TooManyLoadBalancersException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryTooManyRegistrationsForTargetIdExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryTooManyRegistrationsForTargetIdException(body.Error, context);
-    const contents = {
-        name: "TooManyRegistrationsForTargetIdException",
-        $fault: "client",
+    const exception = new models_0_1.TooManyRegistrationsForTargetIdException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryTooManyRulesExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryTooManyRulesException(body.Error, context);
-    const contents = {
-        name: "TooManyRulesException",
-        $fault: "client",
+    const exception = new models_0_1.TooManyRulesException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryTooManyTagsExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryTooManyTagsException(body.Error, context);
-    const contents = {
-        name: "TooManyTagsException",
-        $fault: "client",
+    const exception = new models_0_1.TooManyTagsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryTooManyTargetGroupsExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryTooManyTargetGroupsException(body.Error, context);
-    const contents = {
-        name: "TooManyTargetGroupsException",
-        $fault: "client",
+    const exception = new models_0_1.TooManyTargetGroupsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryTooManyTargetsExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryTooManyTargetsException(body.Error, context);
-    const contents = {
-        name: "TooManyTargetsException",
-        $fault: "client",
+    const exception = new models_0_1.TooManyTargetsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryTooManyUniqueTargetGroupsPerLoadBalancerException(body.Error, context);
-    const contents = {
-        name: "TooManyUniqueTargetGroupsPerLoadBalancerException",
-        $fault: "client",
+    const exception = new models_0_1.TooManyUniqueTargetGroupsPerLoadBalancerException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryUnsupportedProtocolExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryUnsupportedProtocolException(body.Error, context);
-    const contents = {
-        name: "UnsupportedProtocolException",
-        $fault: "client",
+    const exception = new models_0_1.UnsupportedProtocolException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const serializeAws_queryAction = (input, context) => {
     const entries = {};