@aws-sdk/client-lex-models-v2 3.504.0 → 3.509.0

package/dist-es/protocols/Aws_restJson1.js

@@ -121,6 +121,20 @@ export const se_CreateBotLocaleCommand = async (input, context) => {
     b.m("PUT").h(headers).b(body);
     return b.build();
 };
+export const se_CreateBotReplicaCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/bots/{botId}/replicas");
+    b.p("botId", () => input.botId, "{botId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        replicaRegion: [],
+    }));
+    b.m("PUT").h(headers).b(body);
+    return b.build();
+};
 export const se_CreateBotVersionCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -319,6 +333,16 @@ export const se_DeleteBotLocaleCommand = async (input, context) => {
     b.m("DELETE").h(headers).b(body);
     return b.build();
 };
+export const se_DeleteBotReplicaCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/bots/{botId}/replicas/{replicaRegion}");
+    b.p("botId", () => input.botId, "{botId}", false);
+    b.p("replicaRegion", () => input.replicaRegion, "{replicaRegion}", false);
+    let body;
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
+};
 export const se_DeleteBotVersionCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -490,6 +514,16 @@ export const se_DescribeBotRecommendationCommand = async (input, context) => {
     b.m("GET").h(headers).b(body);
     return b.build();
 };
+export const se_DescribeBotReplicaCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/bots/{botId}/replicas/{replicaRegion}");
+    b.p("botId", () => input.botId, "{botId}", false);
+    b.p("replicaRegion", () => input.replicaRegion, "{replicaRegion}", false);
+    let body;
+    b.m("GET").h(headers).b(body);
+    return b.build();
+};
 export const se_DescribeBotResourceGenerationCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -684,6 +718,22 @@ export const se_ListBotAliasesCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_ListBotAliasReplicasCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/bots/{botId}/replicas/{replicaRegion}/botaliases");
+    b.p("botId", () => input.botId, "{botId}", false);
+    b.p("replicaRegion", () => input.replicaRegion, "{replicaRegion}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        maxResults: [],
+        nextToken: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_ListBotLocalesCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -719,6 +769,15 @@ export const se_ListBotRecommendationsCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_ListBotReplicasCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/bots/{botId}/replicas");
+    b.p("botId", () => input.botId, "{botId}", false);
+    let body;
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_ListBotResourceGenerationsCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -753,6 +812,23 @@ export const se_ListBotsCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_ListBotVersionReplicasCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/bots/{botId}/replicas/{replicaRegion}/botversions");
+    b.p("botId", () => input.botId, "{botId}", false);
+    b.p("replicaRegion", () => input.replicaRegion, "{replicaRegion}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        maxResults: [],
+        nextToken: [],
+        sortBy: (_) => _json(_),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_ListBotVersionsCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -1486,7 +1562,7 @@ export const se_UpdateTestSetCommand = async (input, context) => {
 };
 export const de_BatchCreateCustomVocabularyItemCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_BatchCreateCustomVocabularyItemCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1502,40 +1578,9 @@ export const de_BatchCreateCustomVocabularyItemCommand = async (output, context)
     Object.assign(contents, doc);
     return contents;
 };
-const de_BatchCreateCustomVocabularyItemCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_BatchDeleteCustomVocabularyItemCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_BatchDeleteCustomVocabularyItemCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1551,40 +1596,9 @@ export const de_BatchDeleteCustomVocabularyItemCommand = async (output, context)
     Object.assign(contents, doc);
     return contents;
 };
-const de_BatchDeleteCustomVocabularyItemCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_BatchUpdateCustomVocabularyItemCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_BatchUpdateCustomVocabularyItemCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1600,40 +1614,9 @@ export const de_BatchUpdateCustomVocabularyItemCommand = async (output, context)
     Object.assign(contents, doc);
     return contents;
 };
-const de_BatchUpdateCustomVocabularyItemCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_BuildBotLocaleCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_BuildBotLocaleCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1649,43 +1632,9 @@ export const de_BuildBotLocaleCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_BuildBotLocaleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateBotCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_CreateBotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1708,43 +1657,9 @@ export const de_CreateBotCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateBotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateBotAliasCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_CreateBotAliasCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1766,43 +1681,9 @@ export const de_CreateBotAliasCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateBotAliasCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateBotLocaleCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_CreateBotLocaleCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1823,43 +1704,27 @@ export const de_CreateBotLocaleCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateBotLocaleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_CreateBotReplicaCommand = async (output, context) => {
+    if (output.statusCode !== 202 && 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, {
+        botId: __expectString,
+        botReplicaStatus: __expectString,
+        creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        replicaRegion: __expectString,
+        sourceRegion: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
 export const de_CreateBotVersionCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_CreateBotVersionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1876,43 +1741,9 @@ export const de_CreateBotVersionCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateBotVersionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateExportCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_CreateExportCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1928,43 +1759,9 @@ export const de_CreateExportCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateExportCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateIntentCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateIntentCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1992,43 +1789,9 @@ export const de_CreateIntentCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateIntentCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateResourcePolicyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateResourcePolicyCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2041,43 +1804,9 @@ export const de_CreateResourcePolicyCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateResourcePolicyCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateResourcePolicyStatementCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateResourcePolicyStatementCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2090,46 +1819,9 @@ export const de_CreateResourcePolicyStatementCommand = async (output, context) =
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateResourcePolicyStatementCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateSlotCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateSlotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2153,43 +1845,9 @@ export const de_CreateSlotCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateSlotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateSlotTypeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateSlotTypeCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2212,43 +1870,9 @@ export const de_CreateSlotTypeCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateSlotTypeCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateTestSetDiscrepancyReportCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_CreateTestSetDiscrepancyReportCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2263,43 +1887,9 @@ export const de_CreateTestSetDiscrepancyReportCommand = async (output, context)
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateTestSetDiscrepancyReportCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateUploadUrlCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateUploadUrlCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2312,40 +1902,9 @@ export const de_CreateUploadUrlCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateUploadUrlCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteBotCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_DeleteBotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2358,43 +1917,9 @@ export const de_DeleteBotCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteBotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteBotAliasCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_DeleteBotAliasCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2408,43 +1933,9 @@ export const de_DeleteBotAliasCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteBotAliasCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteBotLocaleCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_DeleteBotLocaleCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2459,43 +1950,25 @@ export const de_DeleteBotLocaleCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteBotLocaleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_DeleteBotReplicaCommand = async (output, context) => {
+    if (output.statusCode !== 202 && 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, {
+        botId: __expectString,
+        botReplicaStatus: __expectString,
+        replicaRegion: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
 export const de_DeleteBotVersionCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_DeleteBotVersionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2509,43 +1982,9 @@ export const de_DeleteBotVersionCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteBotVersionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteCustomVocabularyCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_DeleteCustomVocabularyCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2560,43 +1999,9 @@ export const de_DeleteCustomVocabularyCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteCustomVocabularyCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteExportCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_DeleteExportCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2609,40 +2014,9 @@ export const de_DeleteExportCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteExportCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteImportCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_DeleteImportCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2655,40 +2029,9 @@ export const de_DeleteImportCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteImportCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteIntentCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_DeleteIntentCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2696,43 +2039,9 @@ export const de_DeleteIntentCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteIntentCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteResourcePolicyCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_DeleteResourcePolicyCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2745,37 +2054,9 @@ export const de_DeleteResourcePolicyCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteResourcePolicyCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteResourcePolicyStatementCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_DeleteResourcePolicyStatementCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2788,37 +2069,9 @@ export const de_DeleteResourcePolicyStatementCommand = async (output, context) =
     Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteResourcePolicyStatementCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteSlotCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_DeleteSlotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2826,43 +2079,9 @@ export const de_DeleteSlotCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteSlotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteSlotTypeCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_DeleteSlotTypeCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2870,43 +2089,9 @@ export const de_DeleteSlotTypeCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteSlotTypeCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteTestSetCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_DeleteTestSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2914,43 +2099,9 @@ export const de_DeleteTestSetCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteTestSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteUtterancesCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_DeleteUtterancesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2958,34 +2109,9 @@ export const de_DeleteUtterancesCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteUtterancesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeBotCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeBotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3008,40 +2134,9 @@ export const de_DescribeBotCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeBotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeBotAliasCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeBotAliasCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3065,40 +2160,9 @@ export const de_DescribeBotAliasCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeBotAliasCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeBotLocaleCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeBotLocaleCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3126,40 +2190,9 @@ export const de_DescribeBotLocaleCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeBotLocaleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeBotRecommendationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeBotRecommendationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3181,37 +2214,28 @@ export const de_DescribeBotRecommendationCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeBotRecommendationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_DescribeBotReplicaCommand = 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, {
+        botId: __expectString,
+        botReplicaStatus: __expectString,
+        creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        failureReasons: _json,
+        replicaRegion: __expectString,
+        sourceRegion: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
 export const de_DescribeBotResourceGenerationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeBotResourceGenerationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3233,37 +2257,9 @@ export const de_DescribeBotResourceGenerationCommand = async (output, context) =
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeBotResourceGenerationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeBotVersionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeBotVersionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3287,40 +2283,9 @@ export const de_DescribeBotVersionCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeBotVersionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeCustomVocabularyMetadataCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeCustomVocabularyMetadataCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3337,40 +2302,9 @@ export const de_DescribeCustomVocabularyMetadataCommand = async (output, context
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeCustomVocabularyMetadataCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeExportCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeExportCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3389,37 +2323,9 @@ export const de_DescribeExportCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeExportCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeImportCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeImportCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3439,37 +2345,9 @@ export const de_DescribeImportCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeImportCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeIntentCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeIntentCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3499,40 +2377,9 @@ export const de_DescribeIntentCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeIntentCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeResourcePolicyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeResourcePolicyCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3541,97 +2388,41 @@ export const de_DescribeResourcePolicyCommand = async (output, context) => {
     const doc = take(data, {
         policy: __expectString,
         resourceArn: __expectString,
-        revisionId: __expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeResourcePolicyCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeSlotCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeSlotCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    const doc = take(data, {
-        botId: __expectString,
-        botVersion: __expectString,
-        creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
-        description: __expectString,
-        intentId: __expectString,
-        lastUpdatedDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
-        localeId: __expectString,
-        multipleValuesSetting: _json,
-        obfuscationSetting: _json,
-        slotId: __expectString,
-        slotName: __expectString,
-        slotTypeId: __expectString,
-        subSlotSetting: (_) => de_SubSlotSetting(_, context),
-        valueElicitationSetting: (_) => de_SlotValueElicitationSetting(_, context),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeSlotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+        revisionId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_DescribeSlotCommand = 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, {
+        botId: __expectString,
+        botVersion: __expectString,
+        creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        description: __expectString,
+        intentId: __expectString,
+        lastUpdatedDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        localeId: __expectString,
+        multipleValuesSetting: _json,
+        obfuscationSetting: _json,
+        slotId: __expectString,
+        slotName: __expectString,
+        slotTypeId: __expectString,
+        subSlotSetting: (_) => de_SubSlotSetting(_, context),
+        valueElicitationSetting: (_) => de_SlotValueElicitationSetting(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
 export const de_DescribeSlotTypeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeSlotTypeCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3655,40 +2446,9 @@ export const de_DescribeSlotTypeCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeSlotTypeCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeTestExecutionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeTestExecutionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3709,40 +2469,9 @@ export const de_DescribeTestExecutionCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeTestExecutionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeTestSetCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeTestSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3763,40 +2492,9 @@ export const de_DescribeTestSetCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeTestSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeTestSetDiscrepancyReportCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeTestSetDiscrepancyReportCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3816,40 +2514,9 @@ export const de_DescribeTestSetDiscrepancyReportCommand = async (output, context
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeTestSetDiscrepancyReportCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeTestSetGenerationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DescribeTestSetGenerationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3871,40 +2538,9 @@ export const de_DescribeTestSetGenerationCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_DescribeTestSetGenerationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GenerateBotElementCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_GenerateBotElementCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -3920,92 +2556,24 @@ export const de_GenerateBotElementCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_GenerateBotElementCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetTestExecutionArtifactsUrlCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetTestExecutionArtifactsUrlCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    const doc = take(data, {
-        downloadArtifactsUrl: __expectString,
-        testExecutionId: __expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetTestExecutionArtifactsUrlCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+    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, {
+        downloadArtifactsUrl: __expectString,
+        testExecutionId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
 export const de_ListAggregatedUtterancesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListAggregatedUtterancesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4026,37 +2594,9 @@ export const de_ListAggregatedUtterancesCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListAggregatedUtterancesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListBotAliasesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListBotAliasesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4070,37 +2610,27 @@ export const de_ListBotAliasesCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListBotAliasesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_ListBotAliasReplicasCommand = 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, {
+        botAliasReplicaSummaries: (_) => de_BotAliasReplicaSummaryList(_, context),
+        botId: __expectString,
+        nextToken: __expectString,
+        replicaRegion: __expectString,
+        sourceRegion: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
 export const de_ListBotLocalesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListBotLocalesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4115,37 +2645,9 @@ export const de_ListBotLocalesCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListBotLocalesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListBotRecommendationsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListBotRecommendationsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4161,37 +2663,25 @@ export const de_ListBotRecommendationsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListBotRecommendationsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_ListBotReplicasCommand = 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, {
+        botId: __expectString,
+        botReplicaSummaries: (_) => de_BotReplicaSummaryList(_, context),
+        sourceRegion: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
 export const de_ListBotResourceGenerationsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListBotResourceGenerationsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4207,37 +2697,9 @@ export const de_ListBotResourceGenerationsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListBotResourceGenerationsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListBotsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListBotsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4250,37 +2712,27 @@ export const de_ListBotsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListBotsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_ListBotVersionReplicasCommand = 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, {
+        botId: __expectString,
+        botVersionReplicaSummaries: (_) => de_BotVersionReplicaSummaryList(_, context),
+        nextToken: __expectString,
+        replicaRegion: __expectString,
+        sourceRegion: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
 export const de_ListBotVersionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListBotVersionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4294,37 +2746,9 @@ export const de_ListBotVersionsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListBotVersionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListBuiltInIntentsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListBuiltInIntentsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4334,41 +2758,13 @@ export const de_ListBuiltInIntentsCommand = async (output, context) => {
         builtInIntentSummaries: _json,
         localeId: __expectString,
         nextToken: __expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListBuiltInIntentsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
 export const de_ListBuiltInSlotTypesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListBuiltInSlotTypesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4382,37 +2778,9 @@ export const de_ListBuiltInSlotTypesCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListBuiltInSlotTypesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListCustomVocabularyItemsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListCustomVocabularyItemsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4428,40 +2796,9 @@ export const de_ListCustomVocabularyItemsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListCustomVocabularyItemsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListExportsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListExportsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4477,34 +2814,9 @@ export const de_ListExportsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListExportsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListImportsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListImportsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4520,34 +2832,9 @@ export const de_ListImportsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListImportsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListIntentMetricsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListIntentMetricsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4561,40 +2848,9 @@ export const de_ListIntentMetricsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListIntentMetricsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListIntentPathsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListIntentPathsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4606,40 +2862,9 @@ export const de_ListIntentPathsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListIntentPathsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListIntentsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListIntentsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4655,37 +2880,9 @@ export const de_ListIntentsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListIntentsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListIntentStageMetricsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListIntentStageMetricsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4699,40 +2896,9 @@ export const de_ListIntentStageMetricsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListIntentStageMetricsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListRecommendedIntentsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListRecommendedIntentsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4747,42 +2913,11 @@ export const de_ListRecommendedIntentsCommand = async (output, context) => {
         summaryList: _json,
     });
     Object.assign(contents, doc);
-    return contents;
-};
-const de_ListRecommendedIntentsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
+    return contents;
 };
 export const de_ListSessionAnalyticsDataCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListSessionAnalyticsDataCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4796,40 +2931,9 @@ export const de_ListSessionAnalyticsDataCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListSessionAnalyticsDataCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListSessionMetricsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListSessionMetricsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4843,40 +2947,9 @@ export const de_ListSessionMetricsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListSessionMetricsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListSlotsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListSlotsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4893,37 +2966,9 @@ export const de_ListSlotsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListSlotsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListSlotTypesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListSlotTypesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -4939,37 +2984,9 @@ export const de_ListSlotTypesCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListSlotTypesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(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),
@@ -4981,37 +2998,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 "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListTestExecutionResultItemsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListTestExecutionResultItemsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5024,40 +3013,9 @@ export const de_ListTestExecutionResultItemsCommand = async (output, context) =>
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListTestExecutionResultItemsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListTestExecutionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListTestExecutionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5070,37 +3028,9 @@ export const de_ListTestExecutionsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListTestExecutionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListTestSetRecordsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListTestSetRecordsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5113,40 +3043,9 @@ export const de_ListTestSetRecordsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListTestSetRecordsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListTestSetsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListTestSetsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5159,37 +3058,9 @@ export const de_ListTestSetsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListTestSetsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListUtteranceAnalyticsDataCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListUtteranceAnalyticsDataCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5203,40 +3074,9 @@ export const de_ListUtteranceAnalyticsDataCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListUtteranceAnalyticsDataCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListUtteranceMetricsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListUtteranceMetricsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5250,40 +3090,9 @@ export const de_ListUtteranceMetricsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListUtteranceMetricsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_SearchAssociatedTranscriptsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_SearchAssociatedTranscriptsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5301,40 +3110,9 @@ export const de_SearchAssociatedTranscriptsCommand = async (output, context) =>
     Object.assign(contents, doc);
     return contents;
 };
-const de_SearchAssociatedTranscriptsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_StartBotRecommendationCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_StartBotRecommendationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5353,46 +3131,9 @@ export const de_StartBotRecommendationCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_StartBotRecommendationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_StartBotResourceGenerationCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_StartBotResourceGenerationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5410,148 +3151,46 @@ export const de_StartBotResourceGenerationCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_StartBotResourceGenerationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_StartImportCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_StartImportCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    const doc = take(data, {
-        creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
-        importId: __expectString,
-        importStatus: __expectString,
-        mergeStrategy: __expectString,
-        resourceSpecification: (_) => de_ImportResourceSpecification(_, context),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartImportCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_StartTestExecutionCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_StartTestExecutionCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    const doc = take(data, {
-        apiMode: __expectString,
-        creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
-        target: _json,
-        testExecutionId: __expectString,
-        testExecutionModality: __expectString,
-        testSetId: __expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartTestExecutionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+        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, {
+        creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        importId: __expectString,
+        importStatus: __expectString,
+        mergeStrategy: __expectString,
+        resourceSpecification: (_) => de_ImportResourceSpecification(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_StartTestExecutionCommand = async (output, context) => {
+    if (output.statusCode !== 202 && 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, {
+        apiMode: __expectString,
+        creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        target: _json,
+        testExecutionId: __expectString,
+        testExecutionModality: __expectString,
+        testSetId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
 export const de_StartTestSetGenerationCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_StartTestSetGenerationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5571,43 +3210,9 @@ export const de_StartTestSetGenerationCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_StartTestSetGenerationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_StopBotRecommendationCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_StopBotRecommendationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5623,46 +3228,9 @@ export const de_StopBotRecommendationCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_StopBotRecommendationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_TagResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5670,37 +3238,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 "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UntagResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UntagResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5708,37 +3248,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 "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateBotCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_UpdateBotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5760,43 +3272,9 @@ export const de_UpdateBotCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateBotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateBotAliasCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_UpdateBotAliasCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5818,43 +3296,9 @@ export const de_UpdateBotAliasCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateBotAliasCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateBotLocaleCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_UpdateBotLocaleCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5874,47 +3318,13 @@ export const de_UpdateBotLocaleCommand = async (output, context) => {
         nluIntentConfidenceThreshold: __limitedParseDouble,
         recommendedActions: _json,
         voiceSettings: _json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateBotLocaleCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
 export const de_UpdateBotRecommendationCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_UpdateBotRecommendationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5934,46 +3344,9 @@ export const de_UpdateBotRecommendationCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateBotRecommendationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateExportCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_UpdateExportCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -5990,43 +3363,9 @@ export const de_UpdateExportCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateExportCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateIntentCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateIntentCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -6056,43 +3395,9 @@ export const de_UpdateIntentCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateIntentCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateResourcePolicyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateResourcePolicyCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -6105,43 +3410,9 @@ export const de_UpdateResourcePolicyCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateResourcePolicyCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateSlotCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateSlotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -6166,43 +3437,9 @@ export const de_UpdateSlotCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateSlotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateSlotTypeCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_UpdateSlotTypeCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -6226,43 +3463,9 @@ export const de_UpdateSlotTypeCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateSlotTypeCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.lexmodelsv2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.lexmodelsv2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.lexmodelsv2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateTestSetCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateTestSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -6283,22 +3486,19 @@ export const de_UpdateTestSetCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateTestSetCommandError = async (output, context) => {
+const de_CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.lexmodelsv2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.lexmodelsv2#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "PreconditionFailedException":
-        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
-            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.lexmodelsv2#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceQuotaExceededException":
         case "com.amazonaws.lexmodelsv2#ServiceQuotaExceededException":
             throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
@@ -6308,6 +3508,12 @@ const de_UpdateTestSetCommandError = async (output, context) => {
         case "ValidationException":
         case "com.amazonaws.lexmodelsv2#ValidationException":
             throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.lexmodelsv2#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "PreconditionFailedException":
+        case "com.amazonaws.lexmodelsv2#PreconditionFailedException":
+            throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -6815,6 +4021,24 @@ const de_BotAliasHistoryEventsList = (output, context) => {
     });
     return retVal;
 };
+const de_BotAliasReplicaSummary = (output, context) => {
+    return take(output, {
+        botAliasId: __expectString,
+        botAliasReplicationStatus: __expectString,
+        botVersion: __expectString,
+        creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        failureReasons: _json,
+        lastUpdatedDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+    });
+};
+const de_BotAliasReplicaSummaryList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_BotAliasReplicaSummary(entry, context);
+    });
+    return retVal;
+};
 const de_BotAliasSummary = (output, context) => {
     return take(output, {
         botAliasId: __expectString,
@@ -6891,6 +4115,22 @@ const de_BotRecommendationSummaryList = (output, context) => {
     });
     return retVal;
 };
+const de_BotReplicaSummary = (output, context) => {
+    return take(output, {
+        botReplicaStatus: __expectString,
+        creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        failureReasons: _json,
+        replicaRegion: __expectString,
+    });
+};
+const de_BotReplicaSummaryList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_BotReplicaSummary(entry, context);
+    });
+    return retVal;
+};
 const de_BotSummary = (output, context) => {
     return take(output, {
         botId: __expectString,
@@ -6910,6 +4150,22 @@ const de_BotSummaryList = (output, context) => {
     });
     return retVal;
 };
+const de_BotVersionReplicaSummary = (output, context) => {
+    return take(output, {
+        botVersion: __expectString,
+        botVersionReplicationStatus: __expectString,
+        creationDateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        failureReasons: _json,
+    });
+};
+const de_BotVersionReplicaSummaryList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_BotVersionReplicaSummary(entry, context);
+    });
+    return retVal;
+};
 const de_BotVersionSummary = (output, context) => {
     return take(output, {
         botName: __expectString,