@aws-sdk/client-dynamodb 3.506.0 → 3.509.0

package/dist-es/protocols/Aws_json1_0.js

@@ -330,7 +330,7 @@ export const se_UpdateTimeToLiveCommand = async (input, context) => {
 };
 export const de_BatchExecuteStatementCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_BatchExecuteStatementCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -341,31 +341,9 @@ export const de_BatchExecuteStatementCommand = async (output, context) => {
     };
     return response;
 };
-const de_BatchExecuteStatementCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "RequestLimitExceeded":
-        case "com.amazonaws.dynamodb#RequestLimitExceeded":
-            throw await de_RequestLimitExceededRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_BatchGetItemCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_BatchGetItemCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -376,40 +354,9 @@ export const de_BatchGetItemCommand = async (output, context) => {
     };
     return response;
 };
-const de_BatchGetItemCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "ProvisionedThroughputExceededException":
-        case "com.amazonaws.dynamodb#ProvisionedThroughputExceededException":
-            throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
-        case "RequestLimitExceeded":
-        case "com.amazonaws.dynamodb#RequestLimitExceeded":
-            throw await de_RequestLimitExceededRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_BatchWriteItemCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_BatchWriteItemCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -420,43 +367,9 @@ export const de_BatchWriteItemCommand = async (output, context) => {
     };
     return response;
 };
-const de_BatchWriteItemCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "ItemCollectionSizeLimitExceededException":
-        case "com.amazonaws.dynamodb#ItemCollectionSizeLimitExceededException":
-            throw await de_ItemCollectionSizeLimitExceededExceptionRes(parsedOutput, context);
-        case "ProvisionedThroughputExceededException":
-        case "com.amazonaws.dynamodb#ProvisionedThroughputExceededException":
-            throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
-        case "RequestLimitExceeded":
-        case "com.amazonaws.dynamodb#RequestLimitExceeded":
-            throw await de_RequestLimitExceededRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateBackupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateBackupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -467,46 +380,9 @@ export const de_CreateBackupCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateBackupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BackupInUseException":
-        case "com.amazonaws.dynamodb#BackupInUseException":
-            throw await de_BackupInUseExceptionRes(parsedOutput, context);
-        case "ContinuousBackupsUnavailableException":
-        case "com.amazonaws.dynamodb#ContinuousBackupsUnavailableException":
-            throw await de_ContinuousBackupsUnavailableExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "TableInUseException":
-        case "com.amazonaws.dynamodb#TableInUseException":
-            throw await de_TableInUseExceptionRes(parsedOutput, context);
-        case "TableNotFoundException":
-        case "com.amazonaws.dynamodb#TableNotFoundException":
-            throw await de_TableNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateGlobalTableCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateGlobalTableCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -517,40 +393,9 @@ export const de_CreateGlobalTableCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateGlobalTableCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "GlobalTableAlreadyExistsException":
-        case "com.amazonaws.dynamodb#GlobalTableAlreadyExistsException":
-            throw await de_GlobalTableAlreadyExistsExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "TableNotFoundException":
-        case "com.amazonaws.dynamodb#TableNotFoundException":
-            throw await de_TableNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateTableCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateTableCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -561,37 +406,9 @@ export const de_CreateTableCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateTableCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "ResourceInUseException":
-        case "com.amazonaws.dynamodb#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteBackupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteBackupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -602,40 +419,9 @@ export const de_DeleteBackupCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteBackupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BackupInUseException":
-        case "com.amazonaws.dynamodb#BackupInUseException":
-            throw await de_BackupInUseExceptionRes(parsedOutput, context);
-        case "BackupNotFoundException":
-        case "com.amazonaws.dynamodb#BackupNotFoundException":
-            throw await de_BackupNotFoundExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteItemCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteItemCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -646,49 +432,9 @@ export const de_DeleteItemCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteItemCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConditionalCheckFailedException":
-        case "com.amazonaws.dynamodb#ConditionalCheckFailedException":
-            throw await de_ConditionalCheckFailedExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "ItemCollectionSizeLimitExceededException":
-        case "com.amazonaws.dynamodb#ItemCollectionSizeLimitExceededException":
-            throw await de_ItemCollectionSizeLimitExceededExceptionRes(parsedOutput, context);
-        case "ProvisionedThroughputExceededException":
-        case "com.amazonaws.dynamodb#ProvisionedThroughputExceededException":
-            throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
-        case "RequestLimitExceeded":
-        case "com.amazonaws.dynamodb#RequestLimitExceeded":
-            throw await de_RequestLimitExceededRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "TransactionConflictException":
-        case "com.amazonaws.dynamodb#TransactionConflictException":
-            throw await de_TransactionConflictExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteTableCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteTableCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -699,40 +445,9 @@ export const de_DeleteTableCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteTableCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "ResourceInUseException":
-        case "com.amazonaws.dynamodb#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeBackupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeBackupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -743,34 +458,9 @@ export const de_DescribeBackupCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeBackupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BackupNotFoundException":
-        case "com.amazonaws.dynamodb#BackupNotFoundException":
-            throw await de_BackupNotFoundExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeContinuousBackupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeContinuousBackupsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -781,34 +471,9 @@ export const de_DescribeContinuousBackupsCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeContinuousBackupsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "TableNotFoundException":
-        case "com.amazonaws.dynamodb#TableNotFoundException":
-            throw await de_TableNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeContributorInsightsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeContributorInsightsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -819,31 +484,9 @@ export const de_DescribeContributorInsightsCommand = async (output, context) =>
     };
     return response;
 };
-const de_DescribeContributorInsightsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeEndpointsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeEndpointsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -854,22 +497,9 @@ export const de_DescribeEndpointsCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeEndpointsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    const parsedBody = parsedOutput.body;
-    return throwDefaultError({
-        output,
-        parsedBody,
-        errorCode,
-    });
-};
 export const de_DescribeExportCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeExportCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -880,34 +510,9 @@ export const de_DescribeExportCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeExportCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ExportNotFoundException":
-        case "com.amazonaws.dynamodb#ExportNotFoundException":
-            throw await de_ExportNotFoundExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeGlobalTableCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeGlobalTableCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -918,34 +523,9 @@ export const de_DescribeGlobalTableCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeGlobalTableCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "GlobalTableNotFoundException":
-        case "com.amazonaws.dynamodb#GlobalTableNotFoundException":
-            throw await de_GlobalTableNotFoundExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeGlobalTableSettingsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeGlobalTableSettingsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -956,34 +536,9 @@ export const de_DescribeGlobalTableSettingsCommand = async (output, context) =>
     };
     return response;
 };
-const de_DescribeGlobalTableSettingsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "GlobalTableNotFoundException":
-        case "com.amazonaws.dynamodb#GlobalTableNotFoundException":
-            throw await de_GlobalTableNotFoundExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeImportCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeImportCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -994,28 +549,9 @@ export const de_DescribeImportCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeImportCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ImportNotFoundException":
-        case "com.amazonaws.dynamodb#ImportNotFoundException":
-            throw await de_ImportNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeKinesisStreamingDestinationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeKinesisStreamingDestinationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1026,34 +562,9 @@ export const de_DescribeKinesisStreamingDestinationCommand = async (output, cont
     };
     return response;
 };
-const de_DescribeKinesisStreamingDestinationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeLimitsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeLimitsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1064,31 +575,9 @@ export const de_DescribeLimitsCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeLimitsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeTableCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeTableCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1099,34 +588,9 @@ export const de_DescribeTableCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeTableCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeTableReplicaAutoScalingCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeTableReplicaAutoScalingCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1137,31 +601,9 @@ export const de_DescribeTableReplicaAutoScalingCommand = async (output, context)
     };
     return response;
 };
-const de_DescribeTableReplicaAutoScalingCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeTimeToLiveCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeTimeToLiveCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1172,34 +614,9 @@ export const de_DescribeTimeToLiveCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeTimeToLiveCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DisableKinesisStreamingDestinationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DisableKinesisStreamingDestinationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1210,40 +627,9 @@ export const de_DisableKinesisStreamingDestinationCommand = async (output, conte
     };
     return response;
 };
-const de_DisableKinesisStreamingDestinationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "ResourceInUseException":
-        case "com.amazonaws.dynamodb#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_EnableKinesisStreamingDestinationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_EnableKinesisStreamingDestinationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1254,40 +640,9 @@ export const de_EnableKinesisStreamingDestinationCommand = async (output, contex
     };
     return response;
 };
-const de_EnableKinesisStreamingDestinationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "ResourceInUseException":
-        case "com.amazonaws.dynamodb#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ExecuteStatementCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ExecuteStatementCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1298,49 +653,9 @@ export const de_ExecuteStatementCommand = async (output, context) => {
     };
     return response;
 };
-const de_ExecuteStatementCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConditionalCheckFailedException":
-        case "com.amazonaws.dynamodb#ConditionalCheckFailedException":
-            throw await de_ConditionalCheckFailedExceptionRes(parsedOutput, context);
-        case "DuplicateItemException":
-        case "com.amazonaws.dynamodb#DuplicateItemException":
-            throw await de_DuplicateItemExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "ItemCollectionSizeLimitExceededException":
-        case "com.amazonaws.dynamodb#ItemCollectionSizeLimitExceededException":
-            throw await de_ItemCollectionSizeLimitExceededExceptionRes(parsedOutput, context);
-        case "ProvisionedThroughputExceededException":
-        case "com.amazonaws.dynamodb#ProvisionedThroughputExceededException":
-            throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
-        case "RequestLimitExceeded":
-        case "com.amazonaws.dynamodb#RequestLimitExceeded":
-            throw await de_RequestLimitExceededRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "TransactionConflictException":
-        case "com.amazonaws.dynamodb#TransactionConflictException":
-            throw await de_TransactionConflictExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ExecuteTransactionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ExecuteTransactionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1351,46 +666,9 @@ export const de_ExecuteTransactionCommand = async (output, context) => {
     };
     return response;
 };
-const de_ExecuteTransactionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "IdempotentParameterMismatchException":
-        case "com.amazonaws.dynamodb#IdempotentParameterMismatchException":
-            throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "ProvisionedThroughputExceededException":
-        case "com.amazonaws.dynamodb#ProvisionedThroughputExceededException":
-            throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
-        case "RequestLimitExceeded":
-        case "com.amazonaws.dynamodb#RequestLimitExceeded":
-            throw await de_RequestLimitExceededRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "TransactionCanceledException":
-        case "com.amazonaws.dynamodb#TransactionCanceledException":
-            throw await de_TransactionCanceledExceptionRes(parsedOutput, context);
-        case "TransactionInProgressException":
-        case "com.amazonaws.dynamodb#TransactionInProgressException":
-            throw await de_TransactionInProgressExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ExportTableToPointInTimeCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ExportTableToPointInTimeCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1401,43 +679,9 @@ export const de_ExportTableToPointInTimeCommand = async (output, context) => {
     };
     return response;
 };
-const de_ExportTableToPointInTimeCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ExportConflictException":
-        case "com.amazonaws.dynamodb#ExportConflictException":
-            throw await de_ExportConflictExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidExportTimeException":
-        case "com.amazonaws.dynamodb#InvalidExportTimeException":
-            throw await de_InvalidExportTimeExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "PointInTimeRecoveryUnavailableException":
-        case "com.amazonaws.dynamodb#PointInTimeRecoveryUnavailableException":
-            throw await de_PointInTimeRecoveryUnavailableExceptionRes(parsedOutput, context);
-        case "TableNotFoundException":
-        case "com.amazonaws.dynamodb#TableNotFoundException":
-            throw await de_TableNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetItemCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetItemCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1448,40 +692,9 @@ export const de_GetItemCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetItemCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "ProvisionedThroughputExceededException":
-        case "com.amazonaws.dynamodb#ProvisionedThroughputExceededException":
-            throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
-        case "RequestLimitExceeded":
-        case "com.amazonaws.dynamodb#RequestLimitExceeded":
-            throw await de_RequestLimitExceededRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ImportTableCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ImportTableCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1492,69 +705,22 @@ export const de_ImportTableCommand = async (output, context) => {
     };
     return response;
 };
-const de_ImportTableCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ImportConflictException":
-        case "com.amazonaws.dynamodb#ImportConflictException":
-            throw await de_ImportConflictExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "ResourceInUseException":
-        case "com.amazonaws.dynamodb#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListBackupsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_ListBackupsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_ListBackupsOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
+export const de_ListBackupsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ListBackupsOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
     return response;
 };
-const de_ListBackupsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListContributorInsightsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListContributorInsightsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1565,31 +731,9 @@ export const de_ListContributorInsightsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListContributorInsightsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListExportsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListExportsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1600,31 +744,9 @@ export const de_ListExportsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListExportsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListGlobalTablesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListGlobalTablesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1635,31 +757,9 @@ export const de_ListGlobalTablesCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListGlobalTablesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListImportsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListImportsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1670,28 +770,9 @@ export const de_ListImportsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListImportsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListTablesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListTablesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1702,31 +783,9 @@ export const de_ListTablesCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListTablesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListTagsOfResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListTagsOfResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1737,34 +796,9 @@ export const de_ListTagsOfResourceCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListTagsOfResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_PutItemCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_PutItemCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1775,49 +809,9 @@ export const de_PutItemCommand = async (output, context) => {
     };
     return response;
 };
-const de_PutItemCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConditionalCheckFailedException":
-        case "com.amazonaws.dynamodb#ConditionalCheckFailedException":
-            throw await de_ConditionalCheckFailedExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "ItemCollectionSizeLimitExceededException":
-        case "com.amazonaws.dynamodb#ItemCollectionSizeLimitExceededException":
-            throw await de_ItemCollectionSizeLimitExceededExceptionRes(parsedOutput, context);
-        case "ProvisionedThroughputExceededException":
-        case "com.amazonaws.dynamodb#ProvisionedThroughputExceededException":
-            throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
-        case "RequestLimitExceeded":
-        case "com.amazonaws.dynamodb#RequestLimitExceeded":
-            throw await de_RequestLimitExceededRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "TransactionConflictException":
-        case "com.amazonaws.dynamodb#TransactionConflictException":
-            throw await de_TransactionConflictExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_QueryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_QueryCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1828,40 +822,9 @@ export const de_QueryCommand = async (output, context) => {
     };
     return response;
 };
-const de_QueryCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "ProvisionedThroughputExceededException":
-        case "com.amazonaws.dynamodb#ProvisionedThroughputExceededException":
-            throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
-        case "RequestLimitExceeded":
-        case "com.amazonaws.dynamodb#RequestLimitExceeded":
-            throw await de_RequestLimitExceededRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_RestoreTableFromBackupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RestoreTableFromBackupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1872,99 +835,22 @@ export const de_RestoreTableFromBackupCommand = async (output, context) => {
     };
     return response;
 };
-const de_RestoreTableFromBackupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BackupInUseException":
-        case "com.amazonaws.dynamodb#BackupInUseException":
-            throw await de_BackupInUseExceptionRes(parsedOutput, context);
-        case "BackupNotFoundException":
-        case "com.amazonaws.dynamodb#BackupNotFoundException":
-            throw await de_BackupNotFoundExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "TableAlreadyExistsException":
-        case "com.amazonaws.dynamodb#TableAlreadyExistsException":
-            throw await de_TableAlreadyExistsExceptionRes(parsedOutput, context);
-        case "TableInUseException":
-        case "com.amazonaws.dynamodb#TableInUseException":
-            throw await de_TableInUseExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_RestoreTableToPointInTimeCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_RestoreTableToPointInTimeCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_RestoreTableToPointInTimeOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
+export const de_RestoreTableToPointInTimeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_RestoreTableToPointInTimeOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
     return response;
 };
-const de_RestoreTableToPointInTimeCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "InvalidRestoreTimeException":
-        case "com.amazonaws.dynamodb#InvalidRestoreTimeException":
-            throw await de_InvalidRestoreTimeExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "PointInTimeRecoveryUnavailableException":
-        case "com.amazonaws.dynamodb#PointInTimeRecoveryUnavailableException":
-            throw await de_PointInTimeRecoveryUnavailableExceptionRes(parsedOutput, context);
-        case "TableAlreadyExistsException":
-        case "com.amazonaws.dynamodb#TableAlreadyExistsException":
-            throw await de_TableAlreadyExistsExceptionRes(parsedOutput, context);
-        case "TableInUseException":
-        case "com.amazonaws.dynamodb#TableInUseException":
-            throw await de_TableInUseExceptionRes(parsedOutput, context);
-        case "TableNotFoundException":
-        case "com.amazonaws.dynamodb#TableNotFoundException":
-            throw await de_TableNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ScanCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ScanCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1975,40 +861,9 @@ export const de_ScanCommand = async (output, context) => {
     };
     return response;
 };
-const de_ScanCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "ProvisionedThroughputExceededException":
-        case "com.amazonaws.dynamodb#ProvisionedThroughputExceededException":
-            throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
-        case "RequestLimitExceeded":
-        case "com.amazonaws.dynamodb#RequestLimitExceeded":
-            throw await de_RequestLimitExceededRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_TagResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -2016,40 +871,9 @@ export const de_TagResourceCommand = async (output, context) => {
     };
     return response;
 };
-const de_TagResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "ResourceInUseException":
-        case "com.amazonaws.dynamodb#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_TransactGetItemsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_TransactGetItemsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2060,43 +884,9 @@ export const de_TransactGetItemsCommand = async (output, context) => {
     };
     return response;
 };
-const de_TransactGetItemsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "ProvisionedThroughputExceededException":
-        case "com.amazonaws.dynamodb#ProvisionedThroughputExceededException":
-            throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
-        case "RequestLimitExceeded":
-        case "com.amazonaws.dynamodb#RequestLimitExceeded":
-            throw await de_RequestLimitExceededRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "TransactionCanceledException":
-        case "com.amazonaws.dynamodb#TransactionCanceledException":
-            throw await de_TransactionCanceledExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_TransactWriteItemsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_TransactWriteItemsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2107,49 +897,9 @@ export const de_TransactWriteItemsCommand = async (output, context) => {
     };
     return response;
 };
-const de_TransactWriteItemsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "IdempotentParameterMismatchException":
-        case "com.amazonaws.dynamodb#IdempotentParameterMismatchException":
-            throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "ProvisionedThroughputExceededException":
-        case "com.amazonaws.dynamodb#ProvisionedThroughputExceededException":
-            throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
-        case "RequestLimitExceeded":
-        case "com.amazonaws.dynamodb#RequestLimitExceeded":
-            throw await de_RequestLimitExceededRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "TransactionCanceledException":
-        case "com.amazonaws.dynamodb#TransactionCanceledException":
-            throw await de_TransactionCanceledExceptionRes(parsedOutput, context);
-        case "TransactionInProgressException":
-        case "com.amazonaws.dynamodb#TransactionInProgressException":
-            throw await de_TransactionInProgressExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UntagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UntagResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -2157,40 +907,9 @@ export const de_UntagResourceCommand = async (output, context) => {
     };
     return response;
 };
-const de_UntagResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "ResourceInUseException":
-        case "com.amazonaws.dynamodb#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateContinuousBackupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateContinuousBackupsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2201,37 +920,9 @@ export const de_UpdateContinuousBackupsCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateContinuousBackupsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ContinuousBackupsUnavailableException":
-        case "com.amazonaws.dynamodb#ContinuousBackupsUnavailableException":
-            throw await de_ContinuousBackupsUnavailableExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "TableNotFoundException":
-        case "com.amazonaws.dynamodb#TableNotFoundException":
-            throw await de_TableNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateContributorInsightsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateContributorInsightsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2242,78 +933,22 @@ export const de_UpdateContributorInsightsCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateContributorInsightsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateGlobalTableCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateGlobalTableCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_UpdateGlobalTableOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateGlobalTableCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "GlobalTableNotFoundException":
-        case "com.amazonaws.dynamodb#GlobalTableNotFoundException":
-            throw await de_GlobalTableNotFoundExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "ReplicaAlreadyExistsException":
-        case "com.amazonaws.dynamodb#ReplicaAlreadyExistsException":
-            throw await de_ReplicaAlreadyExistsExceptionRes(parsedOutput, context);
-        case "ReplicaNotFoundException":
-        case "com.amazonaws.dynamodb#ReplicaNotFoundException":
-            throw await de_ReplicaNotFoundExceptionRes(parsedOutput, context);
-        case "TableNotFoundException":
-        case "com.amazonaws.dynamodb#TableNotFoundException":
-            throw await de_TableNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
+    let contents = {};
+    contents = de_UpdateGlobalTableOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
 export const de_UpdateGlobalTableSettingsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateGlobalTableSettingsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2324,46 +959,9 @@ export const de_UpdateGlobalTableSettingsCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateGlobalTableSettingsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "GlobalTableNotFoundException":
-        case "com.amazonaws.dynamodb#GlobalTableNotFoundException":
-            throw await de_GlobalTableNotFoundExceptionRes(parsedOutput, context);
-        case "IndexNotFoundException":
-        case "com.amazonaws.dynamodb#IndexNotFoundException":
-            throw await de_IndexNotFoundExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "ReplicaNotFoundException":
-        case "com.amazonaws.dynamodb#ReplicaNotFoundException":
-            throw await de_ReplicaNotFoundExceptionRes(parsedOutput, context);
-        case "ResourceInUseException":
-        case "com.amazonaws.dynamodb#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateItemCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateItemCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2374,49 +972,9 @@ export const de_UpdateItemCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateItemCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConditionalCheckFailedException":
-        case "com.amazonaws.dynamodb#ConditionalCheckFailedException":
-            throw await de_ConditionalCheckFailedExceptionRes(parsedOutput, context);
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "ItemCollectionSizeLimitExceededException":
-        case "com.amazonaws.dynamodb#ItemCollectionSizeLimitExceededException":
-            throw await de_ItemCollectionSizeLimitExceededExceptionRes(parsedOutput, context);
-        case "ProvisionedThroughputExceededException":
-        case "com.amazonaws.dynamodb#ProvisionedThroughputExceededException":
-            throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
-        case "RequestLimitExceeded":
-        case "com.amazonaws.dynamodb#RequestLimitExceeded":
-            throw await de_RequestLimitExceededRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "TransactionConflictException":
-        case "com.amazonaws.dynamodb#TransactionConflictException":
-            throw await de_TransactionConflictExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateKinesisStreamingDestinationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateKinesisStreamingDestinationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2427,40 +985,9 @@ export const de_UpdateKinesisStreamingDestinationCommand = async (output, contex
     };
     return response;
 };
-const de_UpdateKinesisStreamingDestinationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "ResourceInUseException":
-        case "com.amazonaws.dynamodb#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateTableCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateTableCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2471,40 +998,9 @@ export const de_UpdateTableCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateTableCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "InvalidEndpointException":
-        case "com.amazonaws.dynamodb#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "ResourceInUseException":
-        case "com.amazonaws.dynamodb#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateTableReplicaAutoScalingCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateTableReplicaAutoScalingCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2515,37 +1011,9 @@ export const de_UpdateTableReplicaAutoScalingCommand = async (output, context) =
     };
     return response;
 };
-const de_UpdateTableReplicaAutoScalingCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerError":
-        case "com.amazonaws.dynamodb#InternalServerError":
-            throw await de_InternalServerErrorRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.dynamodb#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "ResourceInUseException":
-        case "com.amazonaws.dynamodb#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateTimeToLiveCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateTimeToLiveCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2556,7 +1024,7 @@ export const de_UpdateTimeToLiveCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateTimeToLiveCommandError = async (output, context) => {
+const de_CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2566,18 +1034,99 @@ const de_UpdateTimeToLiveCommandError = async (output, context) => {
         case "InternalServerError":
         case "com.amazonaws.dynamodb#InternalServerError":
             throw await de_InternalServerErrorRes(parsedOutput, context);
+        case "RequestLimitExceeded":
+        case "com.amazonaws.dynamodb#RequestLimitExceeded":
+            throw await de_RequestLimitExceededRes(parsedOutput, context);
         case "InvalidEndpointException":
         case "com.amazonaws.dynamodb#InvalidEndpointException":
             throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
+        case "ProvisionedThroughputExceededException":
+        case "com.amazonaws.dynamodb#ProvisionedThroughputExceededException":
+            throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.dynamodb#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ItemCollectionSizeLimitExceededException":
+        case "com.amazonaws.dynamodb#ItemCollectionSizeLimitExceededException":
+            throw await de_ItemCollectionSizeLimitExceededExceptionRes(parsedOutput, context);
+        case "BackupInUseException":
+        case "com.amazonaws.dynamodb#BackupInUseException":
+            throw await de_BackupInUseExceptionRes(parsedOutput, context);
+        case "ContinuousBackupsUnavailableException":
+        case "com.amazonaws.dynamodb#ContinuousBackupsUnavailableException":
+            throw await de_ContinuousBackupsUnavailableExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.dynamodb#LimitExceededException":
             throw await de_LimitExceededExceptionRes(parsedOutput, context);
+        case "TableInUseException":
+        case "com.amazonaws.dynamodb#TableInUseException":
+            throw await de_TableInUseExceptionRes(parsedOutput, context);
+        case "TableNotFoundException":
+        case "com.amazonaws.dynamodb#TableNotFoundException":
+            throw await de_TableNotFoundExceptionRes(parsedOutput, context);
+        case "GlobalTableAlreadyExistsException":
+        case "com.amazonaws.dynamodb#GlobalTableAlreadyExistsException":
+            throw await de_GlobalTableAlreadyExistsExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.dynamodb#ResourceInUseException":
             throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.dynamodb#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "BackupNotFoundException":
+        case "com.amazonaws.dynamodb#BackupNotFoundException":
+            throw await de_BackupNotFoundExceptionRes(parsedOutput, context);
+        case "ConditionalCheckFailedException":
+        case "com.amazonaws.dynamodb#ConditionalCheckFailedException":
+            throw await de_ConditionalCheckFailedExceptionRes(parsedOutput, context);
+        case "TransactionConflictException":
+        case "com.amazonaws.dynamodb#TransactionConflictException":
+            throw await de_TransactionConflictExceptionRes(parsedOutput, context);
+        case "ExportNotFoundException":
+        case "com.amazonaws.dynamodb#ExportNotFoundException":
+            throw await de_ExportNotFoundExceptionRes(parsedOutput, context);
+        case "GlobalTableNotFoundException":
+        case "com.amazonaws.dynamodb#GlobalTableNotFoundException":
+            throw await de_GlobalTableNotFoundExceptionRes(parsedOutput, context);
+        case "ImportNotFoundException":
+        case "com.amazonaws.dynamodb#ImportNotFoundException":
+            throw await de_ImportNotFoundExceptionRes(parsedOutput, context);
+        case "DuplicateItemException":
+        case "com.amazonaws.dynamodb#DuplicateItemException":
+            throw await de_DuplicateItemExceptionRes(parsedOutput, context);
+        case "IdempotentParameterMismatchException":
+        case "com.amazonaws.dynamodb#IdempotentParameterMismatchException":
+            throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
+        case "TransactionCanceledException":
+        case "com.amazonaws.dynamodb#TransactionCanceledException":
+            throw await de_TransactionCanceledExceptionRes(parsedOutput, context);
+        case "TransactionInProgressException":
+        case "com.amazonaws.dynamodb#TransactionInProgressException":
+            throw await de_TransactionInProgressExceptionRes(parsedOutput, context);
+        case "ExportConflictException":
+        case "com.amazonaws.dynamodb#ExportConflictException":
+            throw await de_ExportConflictExceptionRes(parsedOutput, context);
+        case "InvalidExportTimeException":
+        case "com.amazonaws.dynamodb#InvalidExportTimeException":
+            throw await de_InvalidExportTimeExceptionRes(parsedOutput, context);
+        case "PointInTimeRecoveryUnavailableException":
+        case "com.amazonaws.dynamodb#PointInTimeRecoveryUnavailableException":
+            throw await de_PointInTimeRecoveryUnavailableExceptionRes(parsedOutput, context);
+        case "ImportConflictException":
+        case "com.amazonaws.dynamodb#ImportConflictException":
+            throw await de_ImportConflictExceptionRes(parsedOutput, context);
+        case "TableAlreadyExistsException":
+        case "com.amazonaws.dynamodb#TableAlreadyExistsException":
+            throw await de_TableAlreadyExistsExceptionRes(parsedOutput, context);
+        case "InvalidRestoreTimeException":
+        case "com.amazonaws.dynamodb#InvalidRestoreTimeException":
+            throw await de_InvalidRestoreTimeExceptionRes(parsedOutput, context);
+        case "ReplicaAlreadyExistsException":
+        case "com.amazonaws.dynamodb#ReplicaAlreadyExistsException":
+            throw await de_ReplicaAlreadyExistsExceptionRes(parsedOutput, context);
+        case "ReplicaNotFoundException":
+        case "com.amazonaws.dynamodb#ReplicaNotFoundException":
+            throw await de_ReplicaNotFoundExceptionRes(parsedOutput, context);
+        case "IndexNotFoundException":
+        case "com.amazonaws.dynamodb#IndexNotFoundException":
+            throw await de_IndexNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({