@aws-sdk/client-waf-regional 3.504.0 → 3.507.0

package/dist-es/protocols/Aws_json1_1.js

@@ -490,7 +490,7 @@ export const se_UpdateXssMatchSetCommand = async (input, context) => {
 };
 export const de_AssociateWebACLCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_AssociateWebACLCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -501,40 +501,9 @@ export const de_AssociateWebACLCommand = async (output, context) => {
     };
     return response;
 };
-const de_AssociateWebACLCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFUnavailableEntityException":
-        case "com.amazonaws.wafregional#WAFUnavailableEntityException":
-            throw await de_WAFUnavailableEntityExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateByteMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateByteMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -545,43 +514,9 @@ export const de_CreateByteMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateByteMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.wafregional#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateGeoMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateGeoMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -592,43 +527,9 @@ export const de_CreateGeoMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateGeoMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.wafregional#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateIPSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateIPSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -639,43 +540,9 @@ export const de_CreateIPSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateIPSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.wafregional#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateRateBasedRuleCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateRateBasedRuleCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -686,49 +553,9 @@ export const de_CreateRateBasedRuleCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateRateBasedRuleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFBadRequestException":
-        case "com.amazonaws.wafregional#WAFBadRequestException":
-            throw await de_WAFBadRequestExceptionRes(parsedOutput, context);
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.wafregional#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.wafregional#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.wafregional#WAFTagOperationInternalErrorException":
-            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateRegexMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateRegexMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -739,37 +566,9 @@ export const de_CreateRegexMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateRegexMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.wafregional#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateRegexPatternSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateRegexPatternSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -780,37 +579,35 @@ export const de_CreateRegexPatternSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateRegexPatternSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const de_CreateRuleCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.wafregional#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+    return response;
+};
+export const de_CreateRuleGroupCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_CreateRuleCommand = async (output, context) => {
+export const de_CreateSizeConstraintSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateRuleCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -821,49 +618,22 @@ export const de_CreateRuleCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateRuleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const de_CreateSqlInjectionMatchSetCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFBadRequestException":
-        case "com.amazonaws.wafregional#WAFBadRequestException":
-            throw await de_WAFBadRequestExceptionRes(parsedOutput, context);
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.wafregional#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.wafregional#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.wafregional#WAFTagOperationInternalErrorException":
-            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
+    return response;
 };
-export const de_CreateRuleGroupCommand = async (output, context) => {
+export const de_CreateWebACLCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateRuleGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -874,46 +644,9 @@ export const de_CreateRuleGroupCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateRuleGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFBadRequestException":
-        case "com.amazonaws.wafregional#WAFBadRequestException":
-            throw await de_WAFBadRequestExceptionRes(parsedOutput, context);
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.wafregional#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.wafregional#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.wafregional#WAFTagOperationInternalErrorException":
-            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_CreateSizeConstraintSetCommand = async (output, context) => {
+export const de_CreateWebACLMigrationStackCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateSizeConstraintSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -924,43 +657,9 @@ export const de_CreateSizeConstraintSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateSizeConstraintSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.wafregional#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_CreateSqlInjectionMatchSetCommand = async (output, context) => {
+export const de_CreateXssMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateSqlInjectionMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -971,43 +670,9 @@ export const de_CreateSqlInjectionMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateSqlInjectionMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.wafregional#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_CreateWebACLCommand = async (output, context) => {
+export const de_DeleteByteMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateWebACLCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1018,52 +683,9 @@ export const de_CreateWebACLCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateWebACLCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFBadRequestException":
-        case "com.amazonaws.wafregional#WAFBadRequestException":
-            throw await de_WAFBadRequestExceptionRes(parsedOutput, context);
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.wafregional#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.wafregional#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.wafregional#WAFTagOperationInternalErrorException":
-            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_CreateWebACLMigrationStackCommand = async (output, context) => {
+export const de_DeleteGeoMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateWebACLMigrationStackCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1074,40 +696,9 @@ export const de_CreateWebACLMigrationStackCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateWebACLMigrationStackCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFEntityMigrationException":
-        case "com.amazonaws.wafregional#WAFEntityMigrationException":
-            throw await de_WAFEntityMigrationExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.wafregional#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_CreateXssMatchSetCommand = async (output, context) => {
+export const de_DeleteIPSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateXssMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1118,43 +709,9 @@ export const de_CreateXssMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateXssMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.wafregional#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteByteMatchSetCommand = async (output, context) => {
+export const de_DeleteLoggingConfigurationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteByteMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1165,43 +722,9 @@ export const de_DeleteByteMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteByteMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.wafregional#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteGeoMatchSetCommand = async (output, context) => {
+export const de_DeletePermissionPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteGeoMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1212,43 +735,9 @@ export const de_DeleteGeoMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteGeoMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.wafregional#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteIPSetCommand = async (output, context) => {
+export const de_DeleteRateBasedRuleCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteIPSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1259,43 +748,9 @@ export const de_DeleteIPSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteIPSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.wafregional#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteLoggingConfigurationCommand = async (output, context) => {
+export const de_DeleteRegexMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteLoggingConfigurationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1306,34 +761,9 @@ export const de_DeleteLoggingConfigurationCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteLoggingConfigurationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeletePermissionPolicyCommand = async (output, context) => {
+export const de_DeleteRegexPatternSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeletePermissionPolicyCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1344,34 +774,22 @@ export const de_DeletePermissionPolicyCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeletePermissionPolicyCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_DeleteRuleCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_DeleteRateBasedRuleCommand = async (output, context) => {
+export const de_DeleteRuleGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteRateBasedRuleCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1382,49 +800,22 @@ export const de_DeleteRateBasedRuleCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteRateBasedRuleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.wafregional#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.wafregional#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.wafregional#WAFTagOperationInternalErrorException":
-            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_DeleteSizeConstraintSetCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_DeleteRegexMatchSetCommand = async (output, context) => {
+export const de_DeleteSqlInjectionMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteRegexMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1435,43 +826,22 @@ export const de_DeleteRegexMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteRegexMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.wafregional#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_DeleteWebACLCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_DeleteRegexPatternSetCommand = async (output, context) => {
+export const de_DeleteXssMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteRegexPatternSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1482,43 +852,9 @@ export const de_DeleteRegexPatternSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteRegexPatternSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.wafregional#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteRuleCommand = async (output, context) => {
+export const de_DisassociateWebACLCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteRuleCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1529,49 +865,22 @@ export const de_DeleteRuleCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteRuleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.wafregional#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.wafregional#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.wafregional#WAFTagOperationInternalErrorException":
-            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_GetByteMatchSetCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_GetByteMatchSetResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_DeleteRuleGroupCommand = async (output, context) => {
+export const de_GetChangeTokenCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteRuleGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1582,49 +891,9 @@ export const de_DeleteRuleGroupCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteRuleGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.wafregional#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.wafregional#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.wafregional#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.wafregional#WAFTagOperationInternalErrorException":
-            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteSizeConstraintSetCommand = async (output, context) => {
+export const de_GetChangeTokenStatusCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteSizeConstraintSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1635,43 +904,9 @@ export const de_DeleteSizeConstraintSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteSizeConstraintSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.wafregional#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteSqlInjectionMatchSetCommand = async (output, context) => {
+export const de_GetGeoMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteSqlInjectionMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1682,43 +917,22 @@ export const de_DeleteSqlInjectionMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteSqlInjectionMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.wafregional#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_GetIPSetCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_DeleteWebACLCommand = async (output, context) => {
+export const de_GetLoggingConfigurationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteWebACLCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1729,49 +943,22 @@ export const de_DeleteWebACLCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteWebACLCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.wafregional#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.wafregional#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.wafregional#WAFTagOperationInternalErrorException":
-            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_GetPermissionPolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_DeleteXssMatchSetCommand = async (output, context) => {
+export const de_GetRateBasedRuleCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteXssMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1782,43 +969,9 @@ export const de_DeleteXssMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteXssMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.wafregional#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DisassociateWebACLCommand = async (output, context) => {
+export const de_GetRateBasedRuleManagedKeysCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DisassociateWebACLCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1829,75 +982,22 @@ export const de_DisassociateWebACLCommand = async (output, context) => {
     };
     return response;
 };
-const de_DisassociateWebACLCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetByteMatchSetCommand = async (output, context) => {
+export const de_GetRegexMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetByteMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_GetByteMatchSetResponse(data, context);
+    contents = _json(data);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_GetByteMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetChangeTokenCommand = async (output, context) => {
+export const de_GetRegexPatternSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetChangeTokenCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1908,28 +1008,9 @@ export const de_GetChangeTokenCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetChangeTokenCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetChangeTokenStatusCommand = async (output, context) => {
+export const de_GetRuleCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetChangeTokenStatusCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1940,31 +1021,9 @@ export const de_GetChangeTokenStatusCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetChangeTokenStatusCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetGeoMatchSetCommand = async (output, context) => {
+export const de_GetRuleGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetGeoMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1975,72 +1034,22 @@ export const de_GetGeoMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetGeoMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetIPSetCommand = async (output, context) => {
+export const de_GetSampledRequestsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetIPSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = _json(data);
+    contents = de_GetSampledRequestsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_GetIPSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetLoggingConfigurationCommand = async (output, context) => {
+export const de_GetSizeConstraintSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetLoggingConfigurationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2051,31 +1060,9 @@ export const de_GetLoggingConfigurationCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetLoggingConfigurationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetPermissionPolicyCommand = async (output, context) => {
+export const de_GetSqlInjectionMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetPermissionPolicyCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2086,31 +1073,9 @@ export const de_GetPermissionPolicyCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetPermissionPolicyCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetRateBasedRuleCommand = async (output, context) => {
+export const de_GetWebACLCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetRateBasedRuleCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2121,34 +1086,9 @@ export const de_GetRateBasedRuleCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetRateBasedRuleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetRateBasedRuleManagedKeysCommand = async (output, context) => {
+export const de_GetWebACLForResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetRateBasedRuleManagedKeysCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2159,37 +1099,9 @@ export const de_GetRateBasedRuleManagedKeysCommand = async (output, context) =>
     };
     return response;
 };
-const de_GetRateBasedRuleManagedKeysCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetRegexMatchSetCommand = async (output, context) => {
+export const de_GetXssMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetRegexMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2200,34 +1112,9 @@ export const de_GetRegexMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetRegexMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetRegexPatternSetCommand = async (output, context) => {
+export const de_ListActivatedRulesInRuleGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetRegexPatternSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2238,34 +1125,9 @@ export const de_GetRegexPatternSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetRegexPatternSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetRuleCommand = async (output, context) => {
+export const de_ListByteMatchSetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetRuleCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2276,34 +1138,9 @@ export const de_GetRuleCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetRuleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetRuleGroupCommand = async (output, context) => {
+export const de_ListGeoMatchSetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetRuleGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2314,66 +1151,22 @@ export const de_GetRuleGroupCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetRuleGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetSampledRequestsCommand = async (output, context) => {
+export const de_ListIPSetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetSampledRequestsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_GetSampledRequestsResponse(data, context);
+    contents = _json(data);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_GetSampledRequestsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetSizeConstraintSetCommand = async (output, context) => {
+export const de_ListLoggingConfigurationsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetSizeConstraintSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2384,34 +1177,9 @@ export const de_GetSizeConstraintSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetSizeConstraintSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetSqlInjectionMatchSetCommand = async (output, context) => {
+export const de_ListRateBasedRulesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetSqlInjectionMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2422,34 +1190,22 @@ export const de_GetSqlInjectionMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetSqlInjectionMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_ListRegexMatchSetsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_GetWebACLCommand = async (output, context) => {
+export const de_ListRegexPatternSetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetWebACLCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2460,34 +1216,22 @@ export const de_GetWebACLCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetWebACLCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_ListResourcesForWebACLCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_GetWebACLForResourceCommand = async (output, context) => {
+export const de_ListRuleGroupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetWebACLForResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2498,40 +1242,9 @@ export const de_GetWebACLForResourceCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetWebACLForResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFUnavailableEntityException":
-        case "com.amazonaws.wafregional#WAFUnavailableEntityException":
-            throw await de_WAFUnavailableEntityExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetXssMatchSetCommand = async (output, context) => {
+export const de_ListRulesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetXssMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2542,34 +1255,9 @@ export const de_GetXssMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetXssMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListActivatedRulesInRuleGroupCommand = async (output, context) => {
+export const de_ListSizeConstraintSetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListActivatedRulesInRuleGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2580,34 +1268,9 @@ export const de_ListActivatedRulesInRuleGroupCommand = async (output, context) =
     };
     return response;
 };
-const de_ListActivatedRulesInRuleGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListByteMatchSetsCommand = async (output, context) => {
+export const de_ListSqlInjectionMatchSetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListByteMatchSetsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2618,31 +1281,9 @@ export const de_ListByteMatchSetsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListByteMatchSetsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListGeoMatchSetsCommand = async (output, context) => {
+export const de_ListSubscribedRuleGroupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListGeoMatchSetsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2653,31 +1294,9 @@ export const de_ListGeoMatchSetsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListGeoMatchSetsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListIPSetsCommand = async (output, context) => {
+export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListIPSetsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2688,31 +1307,9 @@ export const de_ListIPSetsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListIPSetsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListLoggingConfigurationsCommand = async (output, context) => {
+export const de_ListWebACLsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListLoggingConfigurationsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2723,34 +1320,9 @@ export const de_ListLoggingConfigurationsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListLoggingConfigurationsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListRateBasedRulesCommand = async (output, context) => {
+export const de_ListXssMatchSetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListRateBasedRulesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2761,31 +1333,9 @@ export const de_ListRateBasedRulesCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListRateBasedRulesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListRegexMatchSetsCommand = async (output, context) => {
+export const de_PutLoggingConfigurationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListRegexMatchSetsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2796,31 +1346,9 @@ export const de_ListRegexMatchSetsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListRegexMatchSetsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListRegexPatternSetsCommand = async (output, context) => {
+export const de_PutPermissionPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListRegexPatternSetsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2831,31 +1359,22 @@ export const de_ListRegexPatternSetsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListRegexPatternSetsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_TagResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_ListResourcesForWebACLCommand = async (output, context) => {
+export const de_UntagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListResourcesForWebACLCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2866,726 +1385,9 @@ export const de_ListResourcesForWebACLCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListResourcesForWebACLCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListRuleGroupsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_ListRuleGroupsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListRuleGroupsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListRulesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_ListRulesCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListRulesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListSizeConstraintSetsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_ListSizeConstraintSetsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListSizeConstraintSetsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListSqlInjectionMatchSetsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_ListSqlInjectionMatchSetsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListSqlInjectionMatchSetsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListSubscribedRuleGroupsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_ListSubscribedRuleGroupsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListSubscribedRuleGroupsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_ListTagsForResourceCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListTagsForResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFBadRequestException":
-        case "com.amazonaws.wafregional#WAFBadRequestException":
-            throw await de_WAFBadRequestExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.wafregional#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.wafregional#WAFTagOperationInternalErrorException":
-            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListWebACLsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_ListWebACLsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListWebACLsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListXssMatchSetsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_ListXssMatchSetsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListXssMatchSetsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_PutLoggingConfigurationCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_PutLoggingConfigurationCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PutLoggingConfigurationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFServiceLinkedRoleErrorException":
-        case "com.amazonaws.wafregional#WAFServiceLinkedRoleErrorException":
-            throw await de_WAFServiceLinkedRoleErrorExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_PutPermissionPolicyCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_PutPermissionPolicyCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PutPermissionPolicyCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidPermissionPolicyException":
-        case "com.amazonaws.wafregional#WAFInvalidPermissionPolicyException":
-            throw await de_WAFInvalidPermissionPolicyExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_TagResourceCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_TagResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFBadRequestException":
-        case "com.amazonaws.wafregional#WAFBadRequestException":
-            throw await de_WAFBadRequestExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.wafregional#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.wafregional#WAFTagOperationInternalErrorException":
-            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_UntagResourceCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UntagResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFBadRequestException":
-        case "com.amazonaws.wafregional#WAFBadRequestException":
-            throw await de_WAFBadRequestExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.wafregional#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.wafregional#WAFTagOperationInternalErrorException":
-            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_UpdateByteMatchSetCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_UpdateByteMatchSetCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateByteMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.wafregional#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.wafregional#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_UpdateGeoMatchSetCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_UpdateGeoMatchSetCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateGeoMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.wafregional#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.wafregional#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_UpdateIPSetCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_UpdateIPSetCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateIPSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.wafregional#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.wafregional#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_UpdateRateBasedRuleCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_UpdateRateBasedRuleCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateRateBasedRuleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.wafregional#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.wafregional#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_UpdateRegexMatchSetCommand = async (output, context) => {
+export const de_UpdateByteMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateRegexMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3596,49 +1398,9 @@ export const de_UpdateRegexMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateRegexMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.wafregional#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.wafregional#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.wafregional#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_UpdateRegexPatternSetCommand = async (output, context) => {
+export const de_UpdateGeoMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateRegexPatternSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3649,49 +1411,9 @@ export const de_UpdateRegexPatternSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateRegexPatternSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.wafregional#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidRegexPatternException":
-        case "com.amazonaws.wafregional#WAFInvalidRegexPatternException":
-            throw await de_WAFInvalidRegexPatternExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.wafregional#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_UpdateRuleCommand = async (output, context) => {
+export const de_UpdateIPSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateRuleCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3702,52 +1424,9 @@ export const de_UpdateRuleCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateRuleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.wafregional#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.wafregional#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_UpdateRuleGroupCommand = async (output, context) => {
+export const de_UpdateRateBasedRuleCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateRuleGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3758,46 +1437,22 @@ export const de_UpdateRuleGroupCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateRuleGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.wafregional#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.wafregional#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_UpdateRegexMatchSetCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_UpdateSizeConstraintSetCommand = async (output, context) => {
+export const de_UpdateRegexPatternSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateSizeConstraintSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3808,52 +1463,22 @@ export const de_UpdateSizeConstraintSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateSizeConstraintSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.wafregional#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.wafregional#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_UpdateRuleCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_UpdateSqlInjectionMatchSetCommand = async (output, context) => {
+export const de_UpdateRuleGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateSqlInjectionMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3864,49 +1489,22 @@ export const de_UpdateSqlInjectionMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateSqlInjectionMatchSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.wafregional#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.wafregional#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_UpdateSizeConstraintSetCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_UpdateWebACLCommand = async (output, context) => {
+export const de_UpdateSqlInjectionMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateWebACLCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3917,55 +1515,22 @@ export const de_UpdateWebACLCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateWebACLCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFInternalErrorException":
-        case "com.amazonaws.wafregional#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.wafregional#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.wafregional#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.wafregional#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.wafregional#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.wafregional#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.wafregional#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.wafregional#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFSubscriptionNotFoundException":
-        case "com.amazonaws.wafregional#WAFSubscriptionNotFoundException":
-            throw await de_WAFSubscriptionNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_UpdateWebACLCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
 export const de_UpdateXssMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateXssMatchSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3976,7 +1541,7 @@ export const de_UpdateXssMatchSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateXssMatchSetCommandError = async (output, context) => {
+const de_CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3989,24 +1554,60 @@ const de_UpdateXssMatchSetCommandError = async (output, context) => {
         case "WAFInvalidAccountException":
         case "com.amazonaws.wafregional#WAFInvalidAccountException":
             throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.wafregional#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
         case "WAFInvalidParameterException":
         case "com.amazonaws.wafregional#WAFInvalidParameterException":
             throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.wafregional#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.wafregional#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
         case "WAFNonexistentItemException":
         case "com.amazonaws.wafregional#WAFNonexistentItemException":
             throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
+        case "WAFUnavailableEntityException":
+        case "com.amazonaws.wafregional#WAFUnavailableEntityException":
+            throw await de_WAFUnavailableEntityExceptionRes(parsedOutput, context);
+        case "WAFDisallowedNameException":
+        case "com.amazonaws.wafregional#WAFDisallowedNameException":
+            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
+        case "WAFLimitsExceededException":
+        case "com.amazonaws.wafregional#WAFLimitsExceededException":
+            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
         case "WAFStaleDataException":
         case "com.amazonaws.wafregional#WAFStaleDataException":
             throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
+        case "WAFBadRequestException":
+        case "com.amazonaws.wafregional#WAFBadRequestException":
+            throw await de_WAFBadRequestExceptionRes(parsedOutput, context);
+        case "WAFTagOperationException":
+        case "com.amazonaws.wafregional#WAFTagOperationException":
+            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
+        case "WAFTagOperationInternalErrorException":
+        case "com.amazonaws.wafregional#WAFTagOperationInternalErrorException":
+            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
+        case "WAFEntityMigrationException":
+        case "com.amazonaws.wafregional#WAFEntityMigrationException":
+            throw await de_WAFEntityMigrationExceptionRes(parsedOutput, context);
+        case "WAFInvalidOperationException":
+        case "com.amazonaws.wafregional#WAFInvalidOperationException":
+            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
+        case "WAFNonEmptyEntityException":
+        case "com.amazonaws.wafregional#WAFNonEmptyEntityException":
+            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
+        case "WAFReferencedItemException":
+        case "com.amazonaws.wafregional#WAFReferencedItemException":
+            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
+        case "WAFServiceLinkedRoleErrorException":
+        case "com.amazonaws.wafregional#WAFServiceLinkedRoleErrorException":
+            throw await de_WAFServiceLinkedRoleErrorExceptionRes(parsedOutput, context);
+        case "WAFInvalidPermissionPolicyException":
+        case "com.amazonaws.wafregional#WAFInvalidPermissionPolicyException":
+            throw await de_WAFInvalidPermissionPolicyExceptionRes(parsedOutput, context);
+        case "WAFNonexistentContainerException":
+        case "com.amazonaws.wafregional#WAFNonexistentContainerException":
+            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
+        case "WAFInvalidRegexPatternException":
+        case "com.amazonaws.wafregional#WAFInvalidRegexPatternException":
+            throw await de_WAFInvalidRegexPatternExceptionRes(parsedOutput, context);
+        case "WAFSubscriptionNotFoundException":
+        case "com.amazonaws.wafregional#WAFSubscriptionNotFoundException":
+            throw await de_WAFSubscriptionNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({