@aws-sdk/client-elastic-load-balancing 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 ElasticLoadBalancingServiceException_1 = require("../models/ElasticLoadBalancingServiceException");
+const models_0_1 = require("../models/models_0");
 const serializeAws_queryAddTagsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -408,43 +410,22 @@ const deserializeAws_queryAddTagsCommandError = async (output, context) => {
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "DuplicateTagKeysException":
         case "com.amazonaws.elasticloadbalancing#DuplicateTagKeysException":
-            response = {
-                ...(await deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.elasticloadbalancing#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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryApplySecurityGroupsToLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -471,43 +452,22 @@ const deserializeAws_queryApplySecurityGroupsToLoadBalancerCommandError = async
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "InvalidSecurityGroupException":
         case "com.amazonaws.elasticloadbalancing#InvalidSecurityGroupException":
-            response = {
-                ...(await deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidSecurityGroupExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryAttachLoadBalancerToSubnetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -534,51 +494,25 @@ const deserializeAws_queryAttachLoadBalancerToSubnetsCommandError = async (outpu
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "InvalidSubnetException":
         case "com.amazonaws.elasticloadbalancing#InvalidSubnetException":
-            response = {
-                ...(await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context);
         case "SubnetNotFoundException":
         case "com.amazonaws.elasticloadbalancing#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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryConfigureHealthCheckCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -605,27 +539,16 @@ const deserializeAws_queryConfigureHealthCheckCommandError = async (output, cont
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryCreateAppCookieStickinessPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -652,51 +575,25 @@ const deserializeAws_queryCreateAppCookieStickinessPolicyCommandError = async (o
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "DuplicatePolicyNameException":
         case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException":
-            response = {
-                ...(await deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "TooManyPoliciesException":
         case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException":
-            response = {
-                ...(await deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyPoliciesExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryCreateLBCookieStickinessPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -723,51 +620,25 @@ const deserializeAws_queryCreateLBCookieStickinessPolicyCommandError = async (ou
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "DuplicatePolicyNameException":
         case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException":
-            response = {
-                ...(await deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "TooManyPoliciesException":
         case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException":
-            response = {
-                ...(await deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyPoliciesExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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) {
@@ -794,115 +665,49 @@ const deserializeAws_queryCreateLoadBalancerCommandError = async (output, contex
     switch (errorCode) {
         case "CertificateNotFoundException":
         case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException":
-            response = {
-                ...(await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context);
         case "DuplicateAccessPointNameException":
         case "com.amazonaws.elasticloadbalancing#DuplicateAccessPointNameException":
-            response = {
-                ...(await deserializeAws_queryDuplicateAccessPointNameExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryDuplicateAccessPointNameExceptionResponse(parsedOutput, context);
         case "DuplicateTagKeysException":
         case "com.amazonaws.elasticloadbalancing#DuplicateTagKeysException":
-            response = {
-                ...(await deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "InvalidSchemeException":
         case "com.amazonaws.elasticloadbalancing#InvalidSchemeException":
-            response = {
-                ...(await deserializeAws_queryInvalidSchemeExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidSchemeExceptionResponse(parsedOutput, context);
         case "InvalidSecurityGroupException":
         case "com.amazonaws.elasticloadbalancing#InvalidSecurityGroupException":
-            response = {
-                ...(await deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context);
         case "InvalidSubnetException":
         case "com.amazonaws.elasticloadbalancing#InvalidSubnetException":
-            response = {
-                ...(await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context);
         case "OperationNotPermittedException":
         case "com.amazonaws.elasticloadbalancing#OperationNotPermittedException":
-            response = {
-                ...(await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context);
         case "SubnetNotFoundException":
         case "com.amazonaws.elasticloadbalancing#SubnetNotFoundException":
-            response = {
-                ...(await deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context);
         case "TooManyAccessPointsException":
         case "com.amazonaws.elasticloadbalancing#TooManyAccessPointsException":
-            response = {
-                ...(await deserializeAws_queryTooManyAccessPointsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyAccessPointsExceptionResponse(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.elasticloadbalancing#TooManyTagsException":
-            response = {
-                ...(await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
         case "UnsupportedProtocolException":
         case "com.amazonaws.elasticloadbalancing#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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryCreateLoadBalancerListenersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -929,59 +734,28 @@ const deserializeAws_queryCreateLoadBalancerListenersCommandError = async (outpu
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "CertificateNotFoundException":
         case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException":
-            response = {
-                ...(await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context);
         case "DuplicateListenerException":
         case "com.amazonaws.elasticloadbalancing#DuplicateListenerException":
-            response = {
-                ...(await deserializeAws_queryDuplicateListenerExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryDuplicateListenerExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "UnsupportedProtocolException":
         case "com.amazonaws.elasticloadbalancing#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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryCreateLoadBalancerPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1008,59 +782,28 @@ const deserializeAws_queryCreateLoadBalancerPolicyCommandError = async (output,
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "DuplicatePolicyNameException":
         case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException":
-            response = {
-                ...(await deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "PolicyTypeNotFoundException":
         case "com.amazonaws.elasticloadbalancing#PolicyTypeNotFoundException":
-            response = {
-                ...(await deserializeAws_queryPolicyTypeNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryPolicyTypeNotFoundExceptionResponse(parsedOutput, context);
         case "TooManyPoliciesException":
         case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException":
-            response = {
-                ...(await deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryTooManyPoliciesExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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) {
@@ -1087,19 +830,13 @@ const deserializeAws_queryDeleteLoadBalancerCommandError = async (output, contex
     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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryDeleteLoadBalancerListenersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1126,27 +863,16 @@ const deserializeAws_queryDeleteLoadBalancerListenersCommandError = async (outpu
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryDeleteLoadBalancerPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1173,35 +899,19 @@ const deserializeAws_queryDeleteLoadBalancerPolicyCommandError = async (output,
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryDeregisterInstancesFromLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1228,35 +938,19 @@ const deserializeAws_queryDeregisterInstancesFromLoadBalancerCommandError = asyn
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "InvalidEndPointException":
         case "com.amazonaws.elasticloadbalancing#InvalidEndPointException":
-            response = {
-                ...(await deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidEndPointExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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) {
@@ -1283,19 +977,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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryDescribeInstanceHealthCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1322,35 +1010,19 @@ const deserializeAws_queryDescribeInstanceHealthCommandError = async (output, co
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "InvalidEndPointException":
         case "com.amazonaws.elasticloadbalancing#InvalidEndPointException":
-            response = {
-                ...(await deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidEndPointExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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) {
@@ -1377,35 +1049,19 @@ const deserializeAws_queryDescribeLoadBalancerAttributesCommandError = async (ou
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "LoadBalancerAttributeNotFoundException":
         case "com.amazonaws.elasticloadbalancing#LoadBalancerAttributeNotFoundException":
-            response = {
-                ...(await deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryDescribeLoadBalancerPoliciesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1432,35 +1088,19 @@ const deserializeAws_queryDescribeLoadBalancerPoliciesCommandError = async (outp
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "PolicyNotFoundException":
         case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException":
-            response = {
-                ...(await deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryPolicyNotFoundExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryDescribeLoadBalancerPolicyTypesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1487,27 +1127,16 @@ const deserializeAws_queryDescribeLoadBalancerPolicyTypesCommandError = async (o
     switch (errorCode) {
         case "PolicyTypeNotFoundException":
         case "com.amazonaws.elasticloadbalancing#PolicyTypeNotFoundException":
-            response = {
-                ...(await deserializeAws_queryPolicyTypeNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryPolicyTypeNotFoundExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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) {
@@ -1534,35 +1163,19 @@ const deserializeAws_queryDescribeLoadBalancersCommandError = async (output, con
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "DependencyThrottleException":
         case "com.amazonaws.elasticloadbalancing#DependencyThrottleException":
-            response = {
-                ...(await deserializeAws_queryDependencyThrottleExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryDependencyThrottleExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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) {
@@ -1589,27 +1202,16 @@ const deserializeAws_queryDescribeTagsCommandError = async (output, context) =>
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryDetachLoadBalancerFromSubnetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1636,35 +1238,19 @@ const deserializeAws_queryDetachLoadBalancerFromSubnetsCommandError = async (out
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryDisableAvailabilityZonesForLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1691,35 +1277,19 @@ const deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommandError =
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryEnableAvailabilityZonesForLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1746,27 +1316,16 @@ const deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommandError = a
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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) {
@@ -1793,43 +1352,22 @@ const deserializeAws_queryModifyLoadBalancerAttributesCommandError = async (outp
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "LoadBalancerAttributeNotFoundException":
         case "com.amazonaws.elasticloadbalancing#LoadBalancerAttributeNotFoundException":
-            response = {
-                ...(await deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryRegisterInstancesWithLoadBalancerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1856,35 +1394,19 @@ const deserializeAws_queryRegisterInstancesWithLoadBalancerCommandError = async
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "InvalidEndPointException":
         case "com.amazonaws.elasticloadbalancing#InvalidEndPointException":
-            response = {
-                ...(await deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidEndPointExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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) {
@@ -1911,27 +1433,16 @@ const deserializeAws_queryRemoveTagsCommandError = async (output, context) => {
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_querySetLoadBalancerListenerSSLCertificateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -1958,59 +1469,28 @@ const deserializeAws_querySetLoadBalancerListenerSSLCertificateCommandError = as
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "CertificateNotFoundException":
         case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException":
-            response = {
-                ...(await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "ListenerNotFoundException":
         case "com.amazonaws.elasticloadbalancing#ListenerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
         case "UnsupportedProtocolException":
         case "com.amazonaws.elasticloadbalancing#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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_querySetLoadBalancerPoliciesForBackendServerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -2037,43 +1517,22 @@ const deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommandError =
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "PolicyNotFoundException":
         case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException":
-            response = {
-                ...(await deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryPolicyNotFoundExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_querySetLoadBalancerPoliciesOfListenerCommand = async (output, context) => {
     if (output.statusCode >= 300) {
@@ -2100,293 +1559,223 @@ const deserializeAws_querySetLoadBalancerPoliciesOfListenerCommandError = async
     switch (errorCode) {
         case "AccessPointNotFoundException":
         case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
-            response = {
-                ...(await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context);
         case "InvalidConfigurationRequestException":
         case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
-            response = {
-                ...(await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context);
         case "ListenerNotFoundException":
         case "com.amazonaws.elasticloadbalancing#ListenerNotFoundException":
-            response = {
-                ...(await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context);
         case "PolicyNotFoundException":
         case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException":
-            response = {
-                ...(await deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
+            throw await deserializeAws_queryPolicyNotFoundExceptionResponse(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 ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException({
+                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_queryAccessPointNotFoundExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryAccessPointNotFoundException(body.Error, context);
-    const contents = {
-        name: "AccessPointNotFoundException",
-        $fault: "client",
+    const exception = new models_0_1.AccessPointNotFoundException({
         $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_queryDependencyThrottleExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryDependencyThrottleException(body.Error, context);
-    const contents = {
-        name: "DependencyThrottleException",
-        $fault: "client",
+    const exception = new models_0_1.DependencyThrottleException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryDuplicateAccessPointNameExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryDuplicateAccessPointNameException(body.Error, context);
-    const contents = {
-        name: "DuplicateAccessPointNameException",
-        $fault: "client",
+    const exception = new models_0_1.DuplicateAccessPointNameException({
         $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_queryDuplicatePolicyNameExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryDuplicatePolicyNameException(body.Error, context);
-    const contents = {
-        name: "DuplicatePolicyNameException",
-        $fault: "client",
+    const exception = new models_0_1.DuplicatePolicyNameException({
         $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_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_queryInvalidEndPointExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryInvalidEndPointException(body.Error, context);
-    const contents = {
-        name: "InvalidEndPointException",
-        $fault: "client",
+    const exception = new models_0_1.InvalidEndPointException({
         $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_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_queryLoadBalancerAttributeNotFoundExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryLoadBalancerAttributeNotFoundException(body.Error, context);
-    const contents = {
-        name: "LoadBalancerAttributeNotFoundException",
-        $fault: "client",
+    const exception = new models_0_1.LoadBalancerAttributeNotFoundException({
         $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_queryPolicyNotFoundExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryPolicyNotFoundException(body.Error, context);
-    const contents = {
-        name: "PolicyNotFoundException",
-        $fault: "client",
+    const exception = new models_0_1.PolicyNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryPolicyTypeNotFoundExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryPolicyTypeNotFoundException(body.Error, context);
-    const contents = {
-        name: "PolicyTypeNotFoundException",
-        $fault: "client",
+    const exception = new models_0_1.PolicyTypeNotFoundException({
         $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_queryTooManyAccessPointsExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryTooManyAccessPointsException(body.Error, context);
-    const contents = {
-        name: "TooManyAccessPointsException",
-        $fault: "client",
+    const exception = new models_0_1.TooManyAccessPointsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
-    };
-    return contents;
+    });
+    return smithy_client_1.decorateServiceException(exception, body);
 };
 const deserializeAws_queryTooManyPoliciesExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_queryTooManyPoliciesException(body.Error, context);
-    const contents = {
-        name: "TooManyPoliciesException",
-        $fault: "client",
+    const exception = new models_0_1.TooManyPoliciesException({
         $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_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_queryAccessLog = (input, context) => {
     const entries = {};