@aws-sdk/client-sfn 3.504.0 → 3.507.0

package/dist-es/protocols/Aws_json1_0.js

@@ -235,7 +235,7 @@ export const se_UpdateStateMachineAliasCommand = async (input, context) => {
 };
 export const de_CreateActivityCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateActivityCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -246,34 +246,9 @@ export const de_CreateActivityCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateActivityCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ActivityLimitExceeded":
-        case "com.amazonaws.sfn#ActivityLimitExceeded":
-            throw await de_ActivityLimitExceededRes(parsedOutput, context);
-        case "InvalidName":
-        case "com.amazonaws.sfn#InvalidName":
-            throw await de_InvalidNameRes(parsedOutput, context);
-        case "TooManyTags":
-        case "com.amazonaws.sfn#TooManyTags":
-            throw await de_TooManyTagsRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateStateMachineCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateStateMachineCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -284,61 +259,9 @@ export const de_CreateStateMachineCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateStateMachineCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.sfn#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "InvalidDefinition":
-        case "com.amazonaws.sfn#InvalidDefinition":
-            throw await de_InvalidDefinitionRes(parsedOutput, context);
-        case "InvalidLoggingConfiguration":
-        case "com.amazonaws.sfn#InvalidLoggingConfiguration":
-            throw await de_InvalidLoggingConfigurationRes(parsedOutput, context);
-        case "InvalidName":
-        case "com.amazonaws.sfn#InvalidName":
-            throw await de_InvalidNameRes(parsedOutput, context);
-        case "InvalidTracingConfiguration":
-        case "com.amazonaws.sfn#InvalidTracingConfiguration":
-            throw await de_InvalidTracingConfigurationRes(parsedOutput, context);
-        case "StateMachineAlreadyExists":
-        case "com.amazonaws.sfn#StateMachineAlreadyExists":
-            throw await de_StateMachineAlreadyExistsRes(parsedOutput, context);
-        case "StateMachineDeleting":
-        case "com.amazonaws.sfn#StateMachineDeleting":
-            throw await de_StateMachineDeletingRes(parsedOutput, context);
-        case "StateMachineLimitExceeded":
-        case "com.amazonaws.sfn#StateMachineLimitExceeded":
-            throw await de_StateMachineLimitExceededRes(parsedOutput, context);
-        case "StateMachineTypeNotSupported":
-        case "com.amazonaws.sfn#StateMachineTypeNotSupported":
-            throw await de_StateMachineTypeNotSupportedRes(parsedOutput, context);
-        case "TooManyTags":
-        case "com.amazonaws.sfn#TooManyTags":
-            throw await de_TooManyTagsRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.sfn#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateStateMachineAliasCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateStateMachineAliasCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -349,46 +272,9 @@ export const de_CreateStateMachineAliasCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateStateMachineAliasCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.sfn#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "InvalidName":
-        case "com.amazonaws.sfn#InvalidName":
-            throw await de_InvalidNameRes(parsedOutput, context);
-        case "ResourceNotFound":
-        case "com.amazonaws.sfn#ResourceNotFound":
-            throw await de_ResourceNotFoundRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.sfn#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "StateMachineDeleting":
-        case "com.amazonaws.sfn#StateMachineDeleting":
-            throw await de_StateMachineDeletingRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.sfn#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteActivityCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteActivityCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -399,28 +285,9 @@ export const de_DeleteActivityCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteActivityCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteStateMachineCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteStateMachineCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -431,31 +298,9 @@ export const de_DeleteStateMachineCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteStateMachineCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.sfn#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteStateMachineAliasCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteStateMachineAliasCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -466,37 +311,9 @@ export const de_DeleteStateMachineAliasCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteStateMachineAliasCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.sfn#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "ResourceNotFound":
-        case "com.amazonaws.sfn#ResourceNotFound":
-            throw await de_ResourceNotFoundRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.sfn#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteStateMachineVersionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteStateMachineVersionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -507,34 +324,9 @@ export const de_DeleteStateMachineVersionCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteStateMachineVersionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.sfn#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.sfn#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeActivityCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeActivityCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -545,31 +337,9 @@ export const de_DescribeActivityCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeActivityCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ActivityDoesNotExist":
-        case "com.amazonaws.sfn#ActivityDoesNotExist":
-            throw await de_ActivityDoesNotExistRes(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeExecutionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeExecutionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -580,31 +350,9 @@ export const de_DescribeExecutionCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeExecutionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ExecutionDoesNotExist":
-        case "com.amazonaws.sfn#ExecutionDoesNotExist":
-            throw await de_ExecutionDoesNotExistRes(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeMapRunCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeMapRunCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -615,66 +363,22 @@ export const de_DescribeMapRunCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeMapRunCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "ResourceNotFound":
-        case "com.amazonaws.sfn#ResourceNotFound":
-            throw await de_ResourceNotFoundRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeStateMachineCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DescribeStateMachineCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeStateMachineOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
+export const de_DescribeStateMachineCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeStateMachineOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
     return response;
 };
-const de_DescribeStateMachineCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "StateMachineDoesNotExist":
-        case "com.amazonaws.sfn#StateMachineDoesNotExist":
-            throw await de_StateMachineDoesNotExistRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeStateMachineAliasCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeStateMachineAliasCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -685,34 +389,9 @@ export const de_DescribeStateMachineAliasCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeStateMachineAliasCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "ResourceNotFound":
-        case "com.amazonaws.sfn#ResourceNotFound":
-            throw await de_ResourceNotFoundRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.sfn#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeStateMachineForExecutionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeStateMachineForExecutionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -723,31 +402,9 @@ export const de_DescribeStateMachineForExecutionCommand = async (output, context
     };
     return response;
 };
-const de_DescribeStateMachineForExecutionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ExecutionDoesNotExist":
-        case "com.amazonaws.sfn#ExecutionDoesNotExist":
-            throw await de_ExecutionDoesNotExistRes(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetActivityTaskCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetActivityTaskCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -758,34 +415,9 @@ export const de_GetActivityTaskCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetActivityTaskCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ActivityDoesNotExist":
-        case "com.amazonaws.sfn#ActivityDoesNotExist":
-            throw await de_ActivityDoesNotExistRes(parsedOutput, context);
-        case "ActivityWorkerLimitExceeded":
-        case "com.amazonaws.sfn#ActivityWorkerLimitExceeded":
-            throw await de_ActivityWorkerLimitExceededRes(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetExecutionHistoryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetExecutionHistoryCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -796,34 +428,9 @@ export const de_GetExecutionHistoryCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetExecutionHistoryCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ExecutionDoesNotExist":
-        case "com.amazonaws.sfn#ExecutionDoesNotExist":
-            throw await de_ExecutionDoesNotExistRes(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await de_InvalidTokenRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListActivitiesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListActivitiesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -834,28 +441,9 @@ export const de_ListActivitiesCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListActivitiesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await de_InvalidTokenRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListExecutionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListExecutionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -866,43 +454,9 @@ export const de_ListExecutionsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListExecutionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await de_InvalidTokenRes(parsedOutput, context);
-        case "ResourceNotFound":
-        case "com.amazonaws.sfn#ResourceNotFound":
-            throw await de_ResourceNotFoundRes(parsedOutput, context);
-        case "StateMachineDoesNotExist":
-        case "com.amazonaws.sfn#StateMachineDoesNotExist":
-            throw await de_StateMachineDoesNotExistRes(parsedOutput, context);
-        case "StateMachineTypeNotSupported":
-        case "com.amazonaws.sfn#StateMachineTypeNotSupported":
-            throw await de_StateMachineTypeNotSupportedRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.sfn#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListMapRunsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListMapRunsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -913,34 +467,9 @@ export const de_ListMapRunsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListMapRunsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ExecutionDoesNotExist":
-        case "com.amazonaws.sfn#ExecutionDoesNotExist":
-            throw await de_ExecutionDoesNotExistRes(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await de_InvalidTokenRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListStateMachineAliasesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListStateMachineAliasesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -951,40 +480,9 @@ export const de_ListStateMachineAliasesCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListStateMachineAliasesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await de_InvalidTokenRes(parsedOutput, context);
-        case "ResourceNotFound":
-        case "com.amazonaws.sfn#ResourceNotFound":
-            throw await de_ResourceNotFoundRes(parsedOutput, context);
-        case "StateMachineDeleting":
-        case "com.amazonaws.sfn#StateMachineDeleting":
-            throw await de_StateMachineDeletingRes(parsedOutput, context);
-        case "StateMachineDoesNotExist":
-        case "com.amazonaws.sfn#StateMachineDoesNotExist":
-            throw await de_StateMachineDoesNotExistRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListStateMachinesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListStateMachinesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -995,28 +493,9 @@ export const de_ListStateMachinesCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListStateMachinesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await de_InvalidTokenRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListStateMachineVersionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListStateMachineVersionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1027,34 +506,9 @@ export const de_ListStateMachineVersionsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListStateMachineVersionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await de_InvalidTokenRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.sfn#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListTagsForResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1065,31 +519,9 @@ export const de_ListTagsForResourceCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListTagsForResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "ResourceNotFound":
-        case "com.amazonaws.sfn#ResourceNotFound":
-            throw await de_ResourceNotFoundRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_PublishStateMachineVersionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_PublishStateMachineVersionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1100,43 +532,9 @@ export const de_PublishStateMachineVersionCommand = async (output, context) => {
     };
     return response;
 };
-const de_PublishStateMachineVersionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.sfn#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.sfn#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "StateMachineDeleting":
-        case "com.amazonaws.sfn#StateMachineDeleting":
-            throw await de_StateMachineDeletingRes(parsedOutput, context);
-        case "StateMachineDoesNotExist":
-        case "com.amazonaws.sfn#StateMachineDoesNotExist":
-            throw await de_StateMachineDoesNotExistRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.sfn#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_RedriveExecutionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RedriveExecutionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1147,37 +545,9 @@ export const de_RedriveExecutionCommand = async (output, context) => {
     };
     return response;
 };
-const de_RedriveExecutionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ExecutionDoesNotExist":
-        case "com.amazonaws.sfn#ExecutionDoesNotExist":
-            throw await de_ExecutionDoesNotExistRes(parsedOutput, context);
-        case "ExecutionLimitExceeded":
-        case "com.amazonaws.sfn#ExecutionLimitExceeded":
-            throw await de_ExecutionLimitExceededRes(parsedOutput, context);
-        case "ExecutionNotRedrivable":
-        case "com.amazonaws.sfn#ExecutionNotRedrivable":
-            throw await de_ExecutionNotRedrivableRes(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_SendTaskFailureCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_SendTaskFailureCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1188,34 +558,9 @@ export const de_SendTaskFailureCommand = async (output, context) => {
     };
     return response;
 };
-const de_SendTaskFailureCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await de_InvalidTokenRes(parsedOutput, context);
-        case "TaskDoesNotExist":
-        case "com.amazonaws.sfn#TaskDoesNotExist":
-            throw await de_TaskDoesNotExistRes(parsedOutput, context);
-        case "TaskTimedOut":
-        case "com.amazonaws.sfn#TaskTimedOut":
-            throw await de_TaskTimedOutRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_SendTaskHeartbeatCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_SendTaskHeartbeatCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1226,34 +571,9 @@ export const de_SendTaskHeartbeatCommand = async (output, context) => {
     };
     return response;
 };
-const de_SendTaskHeartbeatCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await de_InvalidTokenRes(parsedOutput, context);
-        case "TaskDoesNotExist":
-        case "com.amazonaws.sfn#TaskDoesNotExist":
-            throw await de_TaskDoesNotExistRes(parsedOutput, context);
-        case "TaskTimedOut":
-        case "com.amazonaws.sfn#TaskTimedOut":
-            throw await de_TaskTimedOutRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_SendTaskSuccessCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_SendTaskSuccessCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1264,37 +584,9 @@ export const de_SendTaskSuccessCommand = async (output, context) => {
     };
     return response;
 };
-const de_SendTaskSuccessCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidOutput":
-        case "com.amazonaws.sfn#InvalidOutput":
-            throw await de_InvalidOutputRes(parsedOutput, context);
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await de_InvalidTokenRes(parsedOutput, context);
-        case "TaskDoesNotExist":
-        case "com.amazonaws.sfn#TaskDoesNotExist":
-            throw await de_TaskDoesNotExistRes(parsedOutput, context);
-        case "TaskTimedOut":
-        case "com.amazonaws.sfn#TaskTimedOut":
-            throw await de_TaskTimedOutRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_StartExecutionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_StartExecutionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1305,49 +597,9 @@ export const de_StartExecutionCommand = async (output, context) => {
     };
     return response;
 };
-const de_StartExecutionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ExecutionAlreadyExists":
-        case "com.amazonaws.sfn#ExecutionAlreadyExists":
-            throw await de_ExecutionAlreadyExistsRes(parsedOutput, context);
-        case "ExecutionLimitExceeded":
-        case "com.amazonaws.sfn#ExecutionLimitExceeded":
-            throw await de_ExecutionLimitExceededRes(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "InvalidExecutionInput":
-        case "com.amazonaws.sfn#InvalidExecutionInput":
-            throw await de_InvalidExecutionInputRes(parsedOutput, context);
-        case "InvalidName":
-        case "com.amazonaws.sfn#InvalidName":
-            throw await de_InvalidNameRes(parsedOutput, context);
-        case "StateMachineDeleting":
-        case "com.amazonaws.sfn#StateMachineDeleting":
-            throw await de_StateMachineDeletingRes(parsedOutput, context);
-        case "StateMachineDoesNotExist":
-        case "com.amazonaws.sfn#StateMachineDoesNotExist":
-            throw await de_StateMachineDoesNotExistRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.sfn#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_StartSyncExecutionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_StartSyncExecutionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1358,43 +610,9 @@ export const de_StartSyncExecutionCommand = async (output, context) => {
     };
     return response;
 };
-const de_StartSyncExecutionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "InvalidExecutionInput":
-        case "com.amazonaws.sfn#InvalidExecutionInput":
-            throw await de_InvalidExecutionInputRes(parsedOutput, context);
-        case "InvalidName":
-        case "com.amazonaws.sfn#InvalidName":
-            throw await de_InvalidNameRes(parsedOutput, context);
-        case "StateMachineDeleting":
-        case "com.amazonaws.sfn#StateMachineDeleting":
-            throw await de_StateMachineDeletingRes(parsedOutput, context);
-        case "StateMachineDoesNotExist":
-        case "com.amazonaws.sfn#StateMachineDoesNotExist":
-            throw await de_StateMachineDoesNotExistRes(parsedOutput, context);
-        case "StateMachineTypeNotSupported":
-        case "com.amazonaws.sfn#StateMachineTypeNotSupported":
-            throw await de_StateMachineTypeNotSupportedRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_StopExecutionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_StopExecutionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1405,34 +623,9 @@ export const de_StopExecutionCommand = async (output, context) => {
     };
     return response;
 };
-const de_StopExecutionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ExecutionDoesNotExist":
-        case "com.amazonaws.sfn#ExecutionDoesNotExist":
-            throw await de_ExecutionDoesNotExistRes(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.sfn#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_TagResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1443,34 +636,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 "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "ResourceNotFound":
-        case "com.amazonaws.sfn#ResourceNotFound":
-            throw await de_ResourceNotFoundRes(parsedOutput, context);
-        case "TooManyTags":
-        case "com.amazonaws.sfn#TooManyTags":
-            throw await de_TooManyTagsRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_TestStateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_TestStateCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1481,37 +649,9 @@ export const de_TestStateCommand = async (output, context) => {
     };
     return response;
 };
-const de_TestStateCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "InvalidDefinition":
-        case "com.amazonaws.sfn#InvalidDefinition":
-            throw await de_InvalidDefinitionRes(parsedOutput, context);
-        case "InvalidExecutionInput":
-        case "com.amazonaws.sfn#InvalidExecutionInput":
-            throw await de_InvalidExecutionInputRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.sfn#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UntagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UntagResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1522,31 +662,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 "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "ResourceNotFound":
-        case "com.amazonaws.sfn#ResourceNotFound":
-            throw await de_ResourceNotFoundRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateMapRunCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateMapRunCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1557,34 +675,9 @@ export const de_UpdateMapRunCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateMapRunCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "ResourceNotFound":
-        case "com.amazonaws.sfn#ResourceNotFound":
-            throw await de_ResourceNotFoundRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.sfn#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateStateMachineCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateStateMachineCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1595,55 +688,9 @@ export const de_UpdateStateMachineCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateStateMachineCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.sfn#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput, context);
-        case "InvalidDefinition":
-        case "com.amazonaws.sfn#InvalidDefinition":
-            throw await de_InvalidDefinitionRes(parsedOutput, context);
-        case "InvalidLoggingConfiguration":
-        case "com.amazonaws.sfn#InvalidLoggingConfiguration":
-            throw await de_InvalidLoggingConfigurationRes(parsedOutput, context);
-        case "InvalidTracingConfiguration":
-        case "com.amazonaws.sfn#InvalidTracingConfiguration":
-            throw await de_InvalidTracingConfigurationRes(parsedOutput, context);
-        case "MissingRequiredParameter":
-        case "com.amazonaws.sfn#MissingRequiredParameter":
-            throw await de_MissingRequiredParameterRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.sfn#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
-        case "StateMachineDeleting":
-        case "com.amazonaws.sfn#StateMachineDeleting":
-            throw await de_StateMachineDeletingRes(parsedOutput, context);
-        case "StateMachineDoesNotExist":
-        case "com.amazonaws.sfn#StateMachineDoesNotExist":
-            throw await de_StateMachineDoesNotExistRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.sfn#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateStateMachineAliasCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateStateMachineAliasCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1654,28 +701,97 @@ export const de_UpdateStateMachineAliasCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateStateMachineAliasCommandError = async (output, context) => {
+const de_CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "ActivityLimitExceeded":
+        case "com.amazonaws.sfn#ActivityLimitExceeded":
+            throw await de_ActivityLimitExceededRes(parsedOutput, context);
+        case "InvalidName":
+        case "com.amazonaws.sfn#InvalidName":
+            throw await de_InvalidNameRes(parsedOutput, context);
+        case "TooManyTags":
+        case "com.amazonaws.sfn#TooManyTags":
+            throw await de_TooManyTagsRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.sfn#ConflictException":
             throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InvalidArn":
         case "com.amazonaws.sfn#InvalidArn":
             throw await de_InvalidArnRes(parsedOutput, context);
-        case "ResourceNotFound":
-        case "com.amazonaws.sfn#ResourceNotFound":
-            throw await de_ResourceNotFoundRes(parsedOutput, context);
+        case "InvalidDefinition":
+        case "com.amazonaws.sfn#InvalidDefinition":
+            throw await de_InvalidDefinitionRes(parsedOutput, context);
+        case "InvalidLoggingConfiguration":
+        case "com.amazonaws.sfn#InvalidLoggingConfiguration":
+            throw await de_InvalidLoggingConfigurationRes(parsedOutput, context);
+        case "InvalidTracingConfiguration":
+        case "com.amazonaws.sfn#InvalidTracingConfiguration":
+            throw await de_InvalidTracingConfigurationRes(parsedOutput, context);
+        case "StateMachineAlreadyExists":
+        case "com.amazonaws.sfn#StateMachineAlreadyExists":
+            throw await de_StateMachineAlreadyExistsRes(parsedOutput, context);
         case "StateMachineDeleting":
         case "com.amazonaws.sfn#StateMachineDeleting":
             throw await de_StateMachineDeletingRes(parsedOutput, context);
+        case "StateMachineLimitExceeded":
+        case "com.amazonaws.sfn#StateMachineLimitExceeded":
+            throw await de_StateMachineLimitExceededRes(parsedOutput, context);
+        case "StateMachineTypeNotSupported":
+        case "com.amazonaws.sfn#StateMachineTypeNotSupported":
+            throw await de_StateMachineTypeNotSupportedRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.sfn#ValidationException":
             throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ResourceNotFound":
+        case "com.amazonaws.sfn#ResourceNotFound":
+            throw await de_ResourceNotFoundRes(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.sfn#ServiceQuotaExceededException":
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+        case "ActivityDoesNotExist":
+        case "com.amazonaws.sfn#ActivityDoesNotExist":
+            throw await de_ActivityDoesNotExistRes(parsedOutput, context);
+        case "ExecutionDoesNotExist":
+        case "com.amazonaws.sfn#ExecutionDoesNotExist":
+            throw await de_ExecutionDoesNotExistRes(parsedOutput, context);
+        case "StateMachineDoesNotExist":
+        case "com.amazonaws.sfn#StateMachineDoesNotExist":
+            throw await de_StateMachineDoesNotExistRes(parsedOutput, context);
+        case "ActivityWorkerLimitExceeded":
+        case "com.amazonaws.sfn#ActivityWorkerLimitExceeded":
+            throw await de_ActivityWorkerLimitExceededRes(parsedOutput, context);
+        case "InvalidToken":
+        case "com.amazonaws.sfn#InvalidToken":
+            throw await de_InvalidTokenRes(parsedOutput, context);
+        case "ExecutionLimitExceeded":
+        case "com.amazonaws.sfn#ExecutionLimitExceeded":
+            throw await de_ExecutionLimitExceededRes(parsedOutput, context);
+        case "ExecutionNotRedrivable":
+        case "com.amazonaws.sfn#ExecutionNotRedrivable":
+            throw await de_ExecutionNotRedrivableRes(parsedOutput, context);
+        case "TaskDoesNotExist":
+        case "com.amazonaws.sfn#TaskDoesNotExist":
+            throw await de_TaskDoesNotExistRes(parsedOutput, context);
+        case "TaskTimedOut":
+        case "com.amazonaws.sfn#TaskTimedOut":
+            throw await de_TaskTimedOutRes(parsedOutput, context);
+        case "InvalidOutput":
+        case "com.amazonaws.sfn#InvalidOutput":
+            throw await de_InvalidOutputRes(parsedOutput, context);
+        case "ExecutionAlreadyExists":
+        case "com.amazonaws.sfn#ExecutionAlreadyExists":
+            throw await de_ExecutionAlreadyExistsRes(parsedOutput, context);
+        case "InvalidExecutionInput":
+        case "com.amazonaws.sfn#InvalidExecutionInput":
+            throw await de_InvalidExecutionInputRes(parsedOutput, context);
+        case "MissingRequiredParameter":
+        case "com.amazonaws.sfn#MissingRequiredParameter":
+            throw await de_MissingRequiredParameterRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({