@aws-sdk/client-waf 3.504.0 → 3.509.0

package/dist-es/protocols/Aws_json1_1.js

@@ -466,7 +466,7 @@ export const se_UpdateXssMatchSetCommand = async (input, context) => {
 };
 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 = {};
@@ -477,43 +477,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.waf#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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 = {};
@@ -524,43 +490,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.waf#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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 = {};
@@ -571,43 +503,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.waf#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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 = {};
@@ -618,49 +516,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.waf#WAFBadRequestException":
-            throw await de_WAFBadRequestExceptionRes(parsedOutput, context);
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.waf#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.waf#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.waf#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 = {};
@@ -671,37 +529,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.waf#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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 = {};
@@ -712,37 +542,9 @@ export const de_CreateRegexPatternSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateRegexPatternSetCommandError = 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.waf#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateRuleCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateRuleCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -753,49 +555,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),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "WAFBadRequestException":
-        case "com.amazonaws.waf#WAFBadRequestException":
-            throw await de_WAFBadRequestExceptionRes(parsedOutput, context);
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.waf#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.waf#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.waf#WAFTagOperationInternalErrorException":
-            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+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_CreateRuleGroupCommand = async (output, context) => {
+export const de_CreateSizeConstraintSetCommand = 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 = {};
@@ -806,46 +581,22 @@ export const de_CreateRuleGroupCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateRuleGroupCommandError = 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.waf#WAFBadRequestException":
-            throw await de_WAFBadRequestExceptionRes(parsedOutput, context);
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.waf#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.waf#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.waf#WAFTagOperationInternalErrorException":
-            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
+    return response;
 };
-export const de_CreateSizeConstraintSetCommand = async (output, context) => {
+export const de_CreateWebACLCommand = 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 = {};
@@ -856,43 +607,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.waf#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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_CreateWebACLMigrationStackCommand = 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 = {};
@@ -903,43 +620,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.waf#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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_CreateXssMatchSetCommand = 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 = {};
@@ -950,52 +633,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.waf#WAFBadRequestException":
-            throw await de_WAFBadRequestExceptionRes(parsedOutput, context);
-        case "WAFDisallowedNameException":
-        case "com.amazonaws.waf#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.waf#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.waf#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_DeleteByteMatchSetCommand = 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 = {};
@@ -1006,40 +646,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.waf#WAFEntityMigrationException":
-            throw await de_WAFEntityMigrationExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.waf#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_DeleteGeoMatchSetCommand = 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 = {};
@@ -1050,43 +659,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.waf#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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_DeleteIPSetCommand = 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 = {};
@@ -1097,43 +672,22 @@ 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.waf#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_DeleteLoggingConfigurationCommand = 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_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 = {};
@@ -1144,43 +698,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.waf#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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 = {};
@@ -1191,43 +711,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.waf#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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 = {};
@@ -1238,34 +724,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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 = {};
@@ -1276,34 +737,9 @@ 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteRateBasedRuleCommand = async (output, context) => {
+export const de_DeleteRuleCommand = 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 = {};
@@ -1314,49 +750,9 @@ 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.waf#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.waf#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.waf#WAFTagOperationInternalErrorException":
-            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteRegexMatchSetCommand = async (output, context) => {
+export const de_DeleteRuleGroupCommand = 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 = {};
@@ -1367,43 +763,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.waf#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(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_DeleteRegexPatternSetCommand = async (output, context) => {
+export const de_DeleteSqlInjectionMatchSetCommand = 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 = {};
@@ -1414,43 +789,22 @@ 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.waf#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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_DeleteRuleCommand = async (output, context) => {
+export const de_DeleteXssMatchSetCommand = 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 = {};
@@ -1461,49 +815,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.waf#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.waf#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.waf#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 = {};
@@ -1514,49 +841,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.waf#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.waf#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.waf#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.waf#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 = {};
@@ -1567,43 +854,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.waf#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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 = {};
@@ -1614,43 +867,9 @@ 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.waf#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteWebACLCommand = async (output, context) => {
+export const de_GetIPSetCommand = 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 = {};
@@ -1661,49 +880,9 @@ 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.waf#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.waf#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.waf#WAFTagOperationInternalErrorException":
-            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteXssMatchSetCommand = async (output, context) => {
+export const de_GetLoggingConfigurationCommand = 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 = {};
@@ -1714,81 +893,22 @@ 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonEmptyEntityException":
-        case "com.amazonaws.waf#WAFNonEmptyEntityException":
-            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetByteMatchSetCommand = async (output, context) => {
+export const de_GetPermissionPolicyCommand = 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_GetRateBasedRuleCommand = 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 = {};
@@ -1799,28 +919,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.waf#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_GetRateBasedRuleManagedKeysCommand = 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 = {};
@@ -1831,31 +932,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_GetRegexMatchSetCommand = 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 = {};
@@ -1866,34 +945,9 @@ 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_GetRegexPatternSetCommand = 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 = {};
@@ -1904,34 +958,9 @@ export const de_GetIPSetCommand = async (output, context) => {
     };
     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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_GetRuleCommand = 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 = {};
@@ -1942,31 +971,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_GetRuleGroupCommand = 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 = {};
@@ -1977,31 +984,22 @@ 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_GetSampledRequestsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_GetSampledRequestsResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_GetRateBasedRuleCommand = async (output, context) => {
+export const de_GetSizeConstraintSetCommand = 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 = {};
@@ -2012,34 +1010,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_GetSqlInjectionMatchSetCommand = 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 = {};
@@ -2050,37 +1023,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_GetWebACLCommand = 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 = {};
@@ -2091,34 +1036,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_GetXssMatchSetCommand = 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 = {};
@@ -2129,34 +1049,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_ListActivatedRulesInRuleGroupCommand = 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 = {};
@@ -2167,34 +1062,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_ListByteMatchSetsCommand = 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 = {};
@@ -2205,66 +1075,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_ListGeoMatchSetsCommand = 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_ListIPSetsCommand = 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 = {};
@@ -2275,34 +1101,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_ListLoggingConfigurationsCommand = 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 = {};
@@ -2313,34 +1114,9 @@ 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetWebACLCommand = async (output, context) => {
+export const de_ListRateBasedRulesCommand = 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 = {};
@@ -2351,34 +1127,9 @@ 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetXssMatchSetCommand = async (output, context) => {
+export const de_ListRegexMatchSetsCommand = 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 = {};
@@ -2389,34 +1140,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_ListRegexPatternSetsCommand = 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 = {};
@@ -2427,34 +1153,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_ListRuleGroupsCommand = 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 = {};
@@ -2465,31 +1166,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#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_ListRulesCommand = 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 = {};
@@ -2500,31 +1179,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#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_ListSizeConstraintSetsCommand = 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 = {};
@@ -2535,31 +1192,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#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_ListSqlInjectionMatchSetsCommand = 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 = {};
@@ -2570,34 +1205,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#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_ListSubscribedRuleGroupsCommand = 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 = {};
@@ -2608,31 +1218,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#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_ListTagsForResourceCommand = 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 = {};
@@ -2643,31 +1231,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#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_ListWebACLsCommand = 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 = {};
@@ -2678,31 +1244,9 @@ 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListRuleGroupsCommand = async (output, context) => {
+export const de_ListXssMatchSetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListRuleGroupsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2713,28 +1257,9 @@ export const de_ListRuleGroupsCommand = async (output, context) => {
     };
     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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListRulesCommand = async (output, context) => {
+export const de_PutLoggingConfigurationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListRulesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2745,31 +1270,22 @@ export const de_ListRulesCommand = async (output, context) => {
     };
     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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(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_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_ListSizeConstraintSetsCommand = async (output, context) => {
+export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListSizeConstraintSetsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2780,31 +1296,22 @@ export const de_ListSizeConstraintSetsCommand = async (output, context) => {
     };
     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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(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_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_ListSqlInjectionMatchSetsCommand = async (output, context) => {
+export const de_UpdateByteMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListSqlInjectionMatchSetsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2815,31 +1322,22 @@ export const de_ListSqlInjectionMatchSetsCommand = async (output, context) => {
     };
     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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(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_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_ListSubscribedRuleGroupsCommand = async (output, context) => {
+export const de_UpdateIPSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListSubscribedRuleGroupsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2850,31 +1348,22 @@ export const de_ListSubscribedRuleGroupsCommand = async (output, context) => {
     };
     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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(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_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_ListTagsForResourceCommand = async (output, context) => {
+export const de_UpdateRegexMatchSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListTagsForResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2885,566 +1374,9 @@ export const de_ListTagsForResourceCommand = async (output, context) => {
     };
     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.waf#WAFBadRequestException":
-            throw await de_WAFBadRequestExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.waf#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.waf#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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFServiceLinkedRoleErrorException":
-        case "com.amazonaws.waf#WAFServiceLinkedRoleErrorException":
-            throw await de_WAFServiceLinkedRoleErrorExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidPermissionPolicyException":
-        case "com.amazonaws.waf#WAFInvalidPermissionPolicyException":
-            throw await de_WAFInvalidPermissionPolicyExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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.waf#WAFBadRequestException":
-            throw await de_WAFBadRequestExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.waf#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.waf#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.waf#WAFBadRequestException":
-            throw await de_WAFBadRequestExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFTagOperationException":
-        case "com.amazonaws.waf#WAFTagOperationException":
-            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
-        case "WAFTagOperationInternalErrorException":
-        case "com.amazonaws.waf#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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.waf#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.waf#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.waf#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.waf#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.waf#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.waf#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.waf#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.waf#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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_UpdateRegexMatchSetCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    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.waf#WAFDisallowedNameException":
-            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
-        case "WAFInternalErrorException":
-        case "com.amazonaws.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.waf#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.waf#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateRegexPatternSetCommand = 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 = {};
@@ -3453,51 +1385,11 @@ export const de_UpdateRegexPatternSetCommand = async (output, context) => {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
-    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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.waf#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidRegexPatternException":
-        case "com.amazonaws.waf#WAFInvalidRegexPatternException":
-            throw await de_WAFInvalidRegexPatternExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.waf#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
+    return response;
 };
 export const de_UpdateRuleCommand = 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 = {};
@@ -3508,52 +1400,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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.waf#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.waf#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateRuleGroupCommand = 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 = {};
@@ -3564,46 +1413,9 @@ 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.waf#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.waf#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#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_UpdateSizeConstraintSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3614,52 +1426,9 @@ 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.waf#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.waf#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateSqlInjectionMatchSetCommand = 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 = {};
@@ -3670,49 +1439,9 @@ 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.waf#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.waf#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(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_UpdateWebACLCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3723,55 +1452,9 @@ 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.waf#WAFInternalErrorException":
-            throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
-        case "WAFInvalidAccountException":
-        case "com.amazonaws.waf#WAFInvalidAccountException":
-            throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.waf#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
-        case "WAFInvalidParameterException":
-        case "com.amazonaws.waf#WAFInvalidParameterException":
-            throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
-        case "WAFLimitsExceededException":
-        case "com.amazonaws.waf#WAFLimitsExceededException":
-            throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.waf#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
-        case "WAFReferencedItemException":
-        case "com.amazonaws.waf#WAFReferencedItemException":
-            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
-        case "WAFStaleDataException":
-        case "com.amazonaws.waf#WAFStaleDataException":
-            throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
-        case "WAFSubscriptionNotFoundException":
-        case "com.amazonaws.waf#WAFSubscriptionNotFoundException":
-            throw await de_WAFSubscriptionNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 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 = {};
@@ -3782,37 +1465,70 @@ 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),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "WAFDisallowedNameException":
+        case "com.amazonaws.waf#WAFDisallowedNameException":
+            throw await de_WAFDisallowedNameExceptionRes(parsedOutput, context);
         case "WAFInternalErrorException":
         case "com.amazonaws.waf#WAFInternalErrorException":
             throw await de_WAFInternalErrorExceptionRes(parsedOutput, context);
         case "WAFInvalidAccountException":
         case "com.amazonaws.waf#WAFInvalidAccountException":
             throw await de_WAFInvalidAccountExceptionRes(parsedOutput, context);
-        case "WAFInvalidOperationException":
-        case "com.amazonaws.waf#WAFInvalidOperationException":
-            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
         case "WAFInvalidParameterException":
         case "com.amazonaws.waf#WAFInvalidParameterException":
             throw await de_WAFInvalidParameterExceptionRes(parsedOutput, context);
         case "WAFLimitsExceededException":
         case "com.amazonaws.waf#WAFLimitsExceededException":
             throw await de_WAFLimitsExceededExceptionRes(parsedOutput, context);
-        case "WAFNonexistentContainerException":
-        case "com.amazonaws.waf#WAFNonexistentContainerException":
-            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
-        case "WAFNonexistentItemException":
-        case "com.amazonaws.waf#WAFNonexistentItemException":
-            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
         case "WAFStaleDataException":
         case "com.amazonaws.waf#WAFStaleDataException":
             throw await de_WAFStaleDataExceptionRes(parsedOutput, context);
+        case "WAFBadRequestException":
+        case "com.amazonaws.waf#WAFBadRequestException":
+            throw await de_WAFBadRequestExceptionRes(parsedOutput, context);
+        case "WAFTagOperationException":
+        case "com.amazonaws.waf#WAFTagOperationException":
+            throw await de_WAFTagOperationExceptionRes(parsedOutput, context);
+        case "WAFTagOperationInternalErrorException":
+        case "com.amazonaws.waf#WAFTagOperationInternalErrorException":
+            throw await de_WAFTagOperationInternalErrorExceptionRes(parsedOutput, context);
+        case "WAFEntityMigrationException":
+        case "com.amazonaws.waf#WAFEntityMigrationException":
+            throw await de_WAFEntityMigrationExceptionRes(parsedOutput, context);
+        case "WAFInvalidOperationException":
+        case "com.amazonaws.waf#WAFInvalidOperationException":
+            throw await de_WAFInvalidOperationExceptionRes(parsedOutput, context);
+        case "WAFNonexistentItemException":
+        case "com.amazonaws.waf#WAFNonexistentItemException":
+            throw await de_WAFNonexistentItemExceptionRes(parsedOutput, context);
+        case "WAFNonEmptyEntityException":
+        case "com.amazonaws.waf#WAFNonEmptyEntityException":
+            throw await de_WAFNonEmptyEntityExceptionRes(parsedOutput, context);
+        case "WAFReferencedItemException":
+        case "com.amazonaws.waf#WAFReferencedItemException":
+            throw await de_WAFReferencedItemExceptionRes(parsedOutput, context);
+        case "WAFServiceLinkedRoleErrorException":
+        case "com.amazonaws.waf#WAFServiceLinkedRoleErrorException":
+            throw await de_WAFServiceLinkedRoleErrorExceptionRes(parsedOutput, context);
+        case "WAFInvalidPermissionPolicyException":
+        case "com.amazonaws.waf#WAFInvalidPermissionPolicyException":
+            throw await de_WAFInvalidPermissionPolicyExceptionRes(parsedOutput, context);
+        case "WAFNonexistentContainerException":
+        case "com.amazonaws.waf#WAFNonexistentContainerException":
+            throw await de_WAFNonexistentContainerExceptionRes(parsedOutput, context);
+        case "WAFInvalidRegexPatternException":
+        case "com.amazonaws.waf#WAFInvalidRegexPatternException":
+            throw await de_WAFInvalidRegexPatternExceptionRes(parsedOutput, context);
+        case "WAFSubscriptionNotFoundException":
+        case "com.amazonaws.waf#WAFSubscriptionNotFoundException":
+            throw await de_WAFSubscriptionNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({