@aws-sdk/client-kafka 3.503.1 → 3.507.0

package/dist-es/protocols/Aws_restJson1.js

@@ -686,7 +686,7 @@ export const se_UpdateStorageCommand = async (input, context) => {
 };
 export const de_BatchAssociateScramSecretCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_BatchAssociateScramSecretCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -699,46 +699,9 @@ export const de_BatchAssociateScramSecretCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_BatchAssociateScramSecretCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_BatchDisassociateScramSecretCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_BatchDisassociateScramSecretCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -751,46 +714,9 @@ export const de_BatchDisassociateScramSecretCommand = async (output, context) =>
     Object.assign(contents, doc);
     return contents;
 };
-const de_BatchDisassociateScramSecretCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateClusterCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateClusterCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -804,46 +730,9 @@ export const de_CreateClusterCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateClusterCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ConflictException":
-        case "com.amazonaws.kafka#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateClusterV2Command = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateClusterV2CommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -858,46 +747,9 @@ export const de_CreateClusterV2Command = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateClusterV2CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ConflictException":
-        case "com.amazonaws.kafka#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateConfigurationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -913,46 +765,9 @@ export const de_CreateConfigurationCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateConfigurationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ConflictException":
-        case "com.amazonaws.kafka#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateReplicatorCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateReplicatorCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -966,49 +781,9 @@ export const de_CreateReplicatorCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateReplicatorCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ConflictException":
-        case "com.amazonaws.kafka#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateVpcConnectionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateVpcConnectionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1027,43 +802,9 @@ export const de_CreateVpcConnectionCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateVpcConnectionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteClusterCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteClusterCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1076,37 +817,9 @@ export const de_DeleteClusterCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteClusterCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteClusterPolicyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteClusterPolicyCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1114,37 +827,9 @@ export const de_DeleteClusterPolicyCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteClusterPolicyCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteConfigurationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1157,37 +842,9 @@ export const de_DeleteConfigurationCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteConfigurationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteReplicatorCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteReplicatorCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1200,46 +857,9 @@ export const de_DeleteReplicatorCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteReplicatorCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteVpcConnectionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteVpcConnectionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1252,37 +872,9 @@ export const de_DeleteVpcConnectionCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteVpcConnectionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeClusterCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeClusterCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1294,40 +886,9 @@ export const de_DescribeClusterCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeClusterCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeClusterOperationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeClusterOperationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1339,40 +900,9 @@ export const de_DescribeClusterOperationCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeClusterOperationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeClusterOperationV2Command = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeClusterOperationV2CommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1384,46 +914,9 @@ export const de_DescribeClusterOperationV2Command = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeClusterOperationV2CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeClusterV2Command = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeClusterV2CommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1435,40 +928,9 @@ export const de_DescribeClusterV2Command = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeClusterV2CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeConfigurationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1486,43 +948,9 @@ export const de_DescribeConfigurationCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeConfigurationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeConfigurationRevisionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeConfigurationRevisionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1538,43 +966,9 @@ export const de_DescribeConfigurationRevisionCommand = async (output, context) =
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeConfigurationRevisionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeReplicatorCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeReplicatorCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1598,46 +992,9 @@ export const de_DescribeReplicatorCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeReplicatorCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeVpcConnectionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeVpcConnectionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1657,43 +1014,9 @@ export const de_DescribeVpcConnectionCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeVpcConnectionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetBootstrapBrokersCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetBootstrapBrokersCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1714,40 +1037,9 @@ export const de_GetBootstrapBrokersCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetBootstrapBrokersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ConflictException":
-        case "com.amazonaws.kafka#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetClusterPolicyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetClusterPolicyCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1760,37 +1052,9 @@ export const de_GetClusterPolicyCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetClusterPolicyCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetCompatibleKafkaVersionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetCompatibleKafkaVersionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1802,46 +1066,9 @@ export const de_GetCompatibleKafkaVersionsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetCompatibleKafkaVersionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListClientVpcConnectionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListClientVpcConnectionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1854,40 +1081,9 @@ export const de_ListClientVpcConnectionsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListClientVpcConnectionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListClusterOperationsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListClusterOperationsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1900,37 +1096,9 @@ export const de_ListClusterOperationsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListClusterOperationsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListClusterOperationsV2Command = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListClusterOperationsV2CommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1943,46 +1111,9 @@ export const de_ListClusterOperationsV2Command = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListClusterOperationsV2CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListClustersCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListClustersCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1995,37 +1126,9 @@ export const de_ListClustersCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListClustersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListClustersV2Command = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListClustersV2CommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2038,37 +1141,9 @@ export const de_ListClustersV2Command = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListClustersV2CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListConfigurationRevisionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListConfigurationRevisionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2081,43 +1156,9 @@ export const de_ListConfigurationRevisionsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListConfigurationRevisionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListConfigurationsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListConfigurationsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2130,40 +1171,9 @@ export const de_ListConfigurationsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListConfigurationsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListKafkaVersionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListKafkaVersionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2176,37 +1186,9 @@ export const de_ListKafkaVersionsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListKafkaVersionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListNodesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListNodesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2219,37 +1201,9 @@ export const de_ListNodesCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListNodesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListReplicatorsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListReplicatorsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2262,46 +1216,9 @@ export const de_ListReplicatorsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListReplicatorsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListScramSecretsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListScramSecretsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2314,46 +1231,9 @@ export const de_ListScramSecretsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListScramSecretsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListTagsForResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2365,34 +1245,9 @@ export const de_ListTagsForResourceCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListTagsForResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListVpcConnectionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListVpcConnectionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2405,40 +1260,9 @@ export const de_ListVpcConnectionsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListVpcConnectionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_PutClusterPolicyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_PutClusterPolicyCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2450,34 +1274,9 @@ export const de_PutClusterPolicyCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_PutClusterPolicyCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_RebootBrokerCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_RebootBrokerCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2490,46 +1289,9 @@ export const de_RebootBrokerCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_RebootBrokerCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_RejectClientVpcConnectionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_RejectClientVpcConnectionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2537,40 +1299,9 @@ export const de_RejectClientVpcConnectionCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_RejectClientVpcConnectionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_TagResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2578,34 +1309,9 @@ export const de_TagResourceCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_TagResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UntagResourceCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_UntagResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2613,34 +1319,9 @@ export const de_UntagResourceCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_UntagResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateBrokerCountCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateBrokerCountCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2653,86 +1334,9 @@ export const de_UpdateBrokerCountCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateBrokerCountCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateBrokerStorageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateBrokerStorageCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    const doc = take(data, {
-        ClusterArn: [, __expectString, `clusterArn`],
-        ClusterOperationArn: [, __expectString, `clusterOperationArn`],
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateBrokerStorageCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_UpdateBrokerTypeCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateBrokerTypeCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2740,51 +1344,14 @@ export const de_UpdateBrokerTypeCommand = async (output, context) => {
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
         ClusterArn: [, __expectString, `clusterArn`],
-        ClusterOperationArn: [, __expectString, `clusterOperationArn`],
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateBrokerTypeCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
+        ClusterOperationArn: [, __expectString, `clusterOperationArn`],
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
-export const de_UpdateClusterConfigurationCommand = async (output, context) => {
+export const de_UpdateBrokerTypeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateClusterConfigurationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2797,43 +1364,24 @@ export const de_UpdateClusterConfigurationCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateClusterConfigurationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_UpdateClusterConfigurationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        ClusterArn: [, __expectString, `clusterArn`],
+        ClusterOperationArn: [, __expectString, `clusterOperationArn`],
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
 export const de_UpdateClusterKafkaVersionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateClusterKafkaVersionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2846,46 +1394,9 @@ export const de_UpdateClusterKafkaVersionCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateClusterKafkaVersionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateConfigurationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2898,43 +1409,9 @@ export const de_UpdateConfigurationCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateConfigurationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateConnectivityCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateConnectivityCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2947,43 +1424,9 @@ export const de_UpdateConnectivityCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateConnectivityCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateMonitoringCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateMonitoringCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2996,40 +1439,9 @@ export const de_UpdateMonitoringCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateMonitoringCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateReplicationInfoCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateReplicationInfoCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3042,46 +1454,9 @@ export const de_UpdateReplicationInfoCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateReplicationInfoCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateSecurityCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateSecurityCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3094,46 +1469,9 @@ export const de_UpdateSecurityCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateSecurityCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafka#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "com.amazonaws.kafka#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafka#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.kafka#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafka#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafka#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafka#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateStorageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateStorageCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3146,7 +1484,7 @@ export const de_UpdateStorageCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateStorageCommandError = async (output, context) => {
+const de_CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3174,6 +1512,9 @@ const de_UpdateStorageCommandError = async (output, context) => {
         case "UnauthorizedException":
         case "com.amazonaws.kafka#UnauthorizedException":
             throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.kafka#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({