@aws-sdk/client-ecs 3.504.0 → 3.507.0

package/dist-es/protocols/Aws_json1_1.js

@@ -341,7 +341,7 @@ export const se_UpdateTaskSetCommand = async (input, context) => {
 };
 export const de_CreateCapacityProviderCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateCapacityProviderCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -352,40 +352,9 @@ export const de_CreateCapacityProviderCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateCapacityProviderCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.ecs#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "UpdateInProgressException":
-        case "com.amazonaws.ecs#UpdateInProgressException":
-            throw await de_UpdateInProgressExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateClusterCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateClusterCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -396,37 +365,9 @@ export const de_CreateClusterCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateClusterCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "NamespaceNotFoundException":
-        case "com.amazonaws.ecs#NamespaceNotFoundException":
-            throw await de_NamespaceNotFoundExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateServiceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateServiceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -437,52 +378,9 @@ export const de_CreateServiceCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateServiceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.ecs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "NamespaceNotFoundException":
-        case "com.amazonaws.ecs#NamespaceNotFoundException":
-            throw await de_NamespaceNotFoundExceptionRes(parsedOutput, context);
-        case "PlatformTaskDefinitionIncompatibilityException":
-        case "com.amazonaws.ecs#PlatformTaskDefinitionIncompatibilityException":
-            throw await de_PlatformTaskDefinitionIncompatibilityExceptionRes(parsedOutput, context);
-        case "PlatformUnknownException":
-        case "com.amazonaws.ecs#PlatformUnknownException":
-            throw await de_PlatformUnknownExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "UnsupportedFeatureException":
-        case "com.amazonaws.ecs#UnsupportedFeatureException":
-            throw await de_UnsupportedFeatureExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateTaskSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateTaskSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -493,58 +391,9 @@ export const de_CreateTaskSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateTaskSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.ecs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "NamespaceNotFoundException":
-        case "com.amazonaws.ecs#NamespaceNotFoundException":
-            throw await de_NamespaceNotFoundExceptionRes(parsedOutput, context);
-        case "PlatformTaskDefinitionIncompatibilityException":
-        case "com.amazonaws.ecs#PlatformTaskDefinitionIncompatibilityException":
-            throw await de_PlatformTaskDefinitionIncompatibilityExceptionRes(parsedOutput, context);
-        case "PlatformUnknownException":
-        case "com.amazonaws.ecs#PlatformUnknownException":
-            throw await de_PlatformUnknownExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "ServiceNotActiveException":
-        case "com.amazonaws.ecs#ServiceNotActiveException":
-            throw await de_ServiceNotActiveExceptionRes(parsedOutput, context);
-        case "ServiceNotFoundException":
-        case "com.amazonaws.ecs#ServiceNotFoundException":
-            throw await de_ServiceNotFoundExceptionRes(parsedOutput, context);
-        case "UnsupportedFeatureException":
-        case "com.amazonaws.ecs#UnsupportedFeatureException":
-            throw await de_UnsupportedFeatureExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteAccountSettingCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteAccountSettingCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -555,34 +404,9 @@ export const de_DeleteAccountSettingCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteAccountSettingCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteAttributesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteAttributesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -593,34 +417,9 @@ export const de_DeleteAttributesCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteAttributesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "TargetNotFoundException":
-        case "com.amazonaws.ecs#TargetNotFoundException":
-            throw await de_TargetNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteCapacityProviderCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteCapacityProviderCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -631,345 +430,178 @@ export const de_DeleteCapacityProviderCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteCapacityProviderCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const de_DeleteClusterCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+    return response;
+};
+export const de_DeleteServiceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DeleteServiceResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_DeleteClusterCommand = async (output, context) => {
+export const de_DeleteTaskDefinitionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteClusterCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = _json(data);
+    contents = de_DeleteTaskDefinitionsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DeleteClusterCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const de_DeleteTaskSetCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DeleteTaskSetResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterContainsContainerInstancesException":
-        case "com.amazonaws.ecs#ClusterContainsContainerInstancesException":
-            throw await de_ClusterContainsContainerInstancesExceptionRes(parsedOutput, context);
-        case "ClusterContainsServicesException":
-        case "com.amazonaws.ecs#ClusterContainsServicesException":
-            throw await de_ClusterContainsServicesExceptionRes(parsedOutput, context);
-        case "ClusterContainsTasksException":
-        case "com.amazonaws.ecs#ClusterContainsTasksException":
-            throw await de_ClusterContainsTasksExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "UpdateInProgressException":
-        case "com.amazonaws.ecs#UpdateInProgressException":
-            throw await de_UpdateInProgressExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
+    return response;
 };
-export const de_DeleteServiceCommand = async (output, context) => {
+export const de_DeregisterContainerInstanceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteServiceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DeleteServiceResponse(data, context);
+    contents = de_DeregisterContainerInstanceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DeleteServiceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "ServiceNotFoundException":
-        case "com.amazonaws.ecs#ServiceNotFoundException":
-            throw await de_ServiceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteTaskDefinitionsCommand = async (output, context) => {
+export const de_DeregisterTaskDefinitionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteTaskDefinitionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DeleteTaskDefinitionsResponse(data, context);
+    contents = de_DeregisterTaskDefinitionResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DeleteTaskDefinitionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.ecs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteTaskSetCommand = async (output, context) => {
+export const de_DescribeCapacityProvidersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteTaskSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DeleteTaskSetResponse(data, context);
+    contents = _json(data);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DeleteTaskSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.ecs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "ServiceNotActiveException":
-        case "com.amazonaws.ecs#ServiceNotActiveException":
-            throw await de_ServiceNotActiveExceptionRes(parsedOutput, context);
-        case "ServiceNotFoundException":
-        case "com.amazonaws.ecs#ServiceNotFoundException":
-            throw await de_ServiceNotFoundExceptionRes(parsedOutput, context);
-        case "TaskSetNotFoundException":
-        case "com.amazonaws.ecs#TaskSetNotFoundException":
-            throw await de_TaskSetNotFoundExceptionRes(parsedOutput, context);
-        case "UnsupportedFeatureException":
-        case "com.amazonaws.ecs#UnsupportedFeatureException":
-            throw await de_UnsupportedFeatureExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeregisterContainerInstanceCommand = async (output, context) => {
+export const de_DescribeClustersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeregisterContainerInstanceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DeregisterContainerInstanceResponse(data, context);
+    contents = _json(data);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DeregisterContainerInstanceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_DescribeContainerInstancesCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeContainerInstancesResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_DeregisterTaskDefinitionCommand = async (output, context) => {
+export const de_DescribeServicesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeregisterTaskDefinitionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DeregisterTaskDefinitionResponse(data, context);
+    contents = de_DescribeServicesResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DeregisterTaskDefinitionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_DescribeTaskDefinitionCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeTaskDefinitionResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_DescribeCapacityProvidersCommand = async (output, context) => {
+export const de_DescribeTasksCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeCapacityProvidersCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = _json(data);
+    contents = de_DescribeTasksResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeCapacityProvidersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_DescribeTaskSetsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeTaskSetsResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_DescribeClustersCommand = async (output, context) => {
+export const de_DiscoverPollEndpointCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeClustersCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -980,248 +612,74 @@ export const de_DescribeClustersCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeClustersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeContainerInstancesCommand = async (output, context) => {
+export const de_ExecuteCommandCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeContainerInstancesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeContainerInstancesResponse(data, context);
+    contents = _json(data);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeContainerInstancesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeServicesCommand = async (output, context) => {
+export const de_GetTaskProtectionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeServicesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeServicesResponse(data, context);
+    contents = de_GetTaskProtectionResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeServicesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeTaskDefinitionCommand = async (output, context) => {
+export const de_ListAccountSettingsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeTaskDefinitionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeTaskDefinitionResponse(data, context);
+    contents = _json(data);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeTaskDefinitionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeTasksCommand = async (output, context) => {
+export const de_ListAttributesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeTasksCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeTasksResponse(data, context);
+    contents = _json(data);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeTasksCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeTaskSetsCommand = async (output, context) => {
+export const de_ListClustersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeTaskSetsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeTaskSetsResponse(data, context);
+    contents = _json(data);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeTaskSetsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.ecs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "ServiceNotActiveException":
-        case "com.amazonaws.ecs#ServiceNotActiveException":
-            throw await de_ServiceNotActiveExceptionRes(parsedOutput, context);
-        case "ServiceNotFoundException":
-        case "com.amazonaws.ecs#ServiceNotFoundException":
-            throw await de_ServiceNotFoundExceptionRes(parsedOutput, context);
-        case "UnsupportedFeatureException":
-        case "com.amazonaws.ecs#UnsupportedFeatureException":
-            throw await de_UnsupportedFeatureExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DiscoverPollEndpointCommand = async (output, context) => {
+export const de_ListContainerInstancesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DiscoverPollEndpointCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1232,31 +690,9 @@ export const de_DiscoverPollEndpointCommand = async (output, context) => {
     };
     return response;
 };
-const de_DiscoverPollEndpointCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ExecuteCommandCommand = async (output, context) => {
+export const de_ListServicesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ExecuteCommandCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1267,93 +703,22 @@ export const de_ExecuteCommandCommand = async (output, context) => {
     };
     return response;
 };
-const de_ExecuteCommandCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.ecs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "TargetNotConnectedException":
-        case "com.amazonaws.ecs#TargetNotConnectedException":
-            throw await de_TargetNotConnectedExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetTaskProtectionCommand = async (output, context) => {
+export const de_ListServicesByNamespaceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetTaskProtectionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_GetTaskProtectionResponse(data, context);
+    contents = _json(data);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_GetTaskProtectionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.ecs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.ecs#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "UnsupportedFeatureException":
-        case "com.amazonaws.ecs#UnsupportedFeatureException":
-            throw await de_UnsupportedFeatureExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListAccountSettingsCommand = async (output, context) => {
+export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListAccountSettingsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1364,34 +729,9 @@ export const de_ListAccountSettingsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListAccountSettingsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListAttributesCommand = async (output, context) => {
+export const de_ListTaskDefinitionFamiliesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListAttributesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1402,31 +742,9 @@ export const de_ListAttributesCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListAttributesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListClustersCommand = async (output, context) => {
+export const de_ListTaskDefinitionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListClustersCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1437,34 +755,9 @@ export const de_ListClustersCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListClustersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListContainerInstancesCommand = async (output, context) => {
+export const de_ListTasksCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListContainerInstancesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1475,37 +768,9 @@ export const de_ListContainerInstancesCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListContainerInstancesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListServicesCommand = async (output, context) => {
+export const de_PutAccountSettingCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListServicesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1516,37 +781,9 @@ export const de_ListServicesCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListServicesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListServicesByNamespaceCommand = async (output, context) => {
+export const de_PutAccountSettingDefaultCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListServicesByNamespaceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1557,37 +794,9 @@ export const de_ListServicesByNamespaceCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListServicesByNamespaceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "NamespaceNotFoundException":
-        case "com.amazonaws.ecs#NamespaceNotFoundException":
-            throw await de_NamespaceNotFoundExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListTagsForResourceCommand = async (output, context) => {
+export const de_PutAttributesCommand = 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 = {};
@@ -1598,37 +807,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 "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListTaskDefinitionFamiliesCommand = async (output, context) => {
+export const de_PutClusterCapacityProvidersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListTaskDefinitionFamiliesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1639,318 +820,22 @@ export const de_ListTaskDefinitionFamiliesCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListTaskDefinitionFamiliesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListTaskDefinitionsCommand = async (output, context) => {
+export const de_RegisterContainerInstanceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListTaskDefinitionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = _json(data);
+    contents = de_RegisterContainerInstanceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ListTaskDefinitionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListTasksCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_ListTasksCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListTasksCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "ServiceNotFoundException":
-        case "com.amazonaws.ecs#ServiceNotFoundException":
-            throw await de_ServiceNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_PutAccountSettingCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_PutAccountSettingCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PutAccountSettingCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_PutAccountSettingDefaultCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_PutAccountSettingDefaultCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PutAccountSettingDefaultCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_PutAttributesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_PutAttributesCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PutAttributesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AttributeLimitExceededException":
-        case "com.amazonaws.ecs#AttributeLimitExceededException":
-            throw await de_AttributeLimitExceededExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "TargetNotFoundException":
-        case "com.amazonaws.ecs#TargetNotFoundException":
-            throw await de_TargetNotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_PutClusterCapacityProvidersCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_PutClusterCapacityProvidersCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PutClusterCapacityProvidersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ResourceInUseException":
-        case "com.amazonaws.ecs#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "UpdateInProgressException":
-        case "com.amazonaws.ecs#UpdateInProgressException":
-            throw await de_UpdateInProgressExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_RegisterContainerInstanceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_RegisterContainerInstanceCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_RegisterContainerInstanceResponse(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_RegisterContainerInstanceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_RegisterTaskDefinitionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RegisterTaskDefinitionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1961,342 +846,48 @@ export const de_RegisterTaskDefinitionCommand = async (output, context) => {
     };
     return response;
 };
-const de_RegisterTaskDefinitionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_RunTaskCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RunTaskCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_RunTaskResponse(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_RunTaskCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.ecs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "BlockedException":
-        case "com.amazonaws.ecs#BlockedException":
-            throw await de_BlockedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "ConflictException":
-        case "com.amazonaws.ecs#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "PlatformTaskDefinitionIncompatibilityException":
-        case "com.amazonaws.ecs#PlatformTaskDefinitionIncompatibilityException":
-            throw await de_PlatformTaskDefinitionIncompatibilityExceptionRes(parsedOutput, context);
-        case "PlatformUnknownException":
-        case "com.amazonaws.ecs#PlatformUnknownException":
-            throw await de_PlatformUnknownExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "UnsupportedFeatureException":
-        case "com.amazonaws.ecs#UnsupportedFeatureException":
-            throw await de_UnsupportedFeatureExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_StartTaskCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_StartTaskCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_StartTaskResponse(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_StartTaskCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "UnsupportedFeatureException":
-        case "com.amazonaws.ecs#UnsupportedFeatureException":
-            throw await de_UnsupportedFeatureExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_StopTaskCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_StopTaskCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_StopTaskResponse(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_StopTaskCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_SubmitAttachmentStateChangesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_SubmitAttachmentStateChangesCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_SubmitAttachmentStateChangesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.ecs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_SubmitContainerStateChangeCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_SubmitContainerStateChangeCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = _json(data);
+    contents = de_RunTaskResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_SubmitContainerStateChangeCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.ecs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_SubmitTaskStateChangeCommand = async (output, context) => {
+export const de_StartTaskCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_SubmitTaskStateChangeCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = _json(data);
+    contents = de_StartTaskResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_SubmitTaskStateChangeCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.ecs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_TagResourceCommand = async (output, context) => {
+export const de_StopTaskCommand = 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 = {};
-    contents = _json(data);
+    contents = de_StopTaskResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_TagResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.ecs#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_UntagResourceCommand = async (output, context) => {
+export const de_SubmitAttachmentStateChangesCommand = 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 = {};
@@ -2307,40 +898,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 "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.ecs#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_UpdateCapacityProviderCommand = async (output, context) => {
+export const de_SubmitContainerStateChangeCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateCapacityProviderCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2351,34 +911,9 @@ export const de_UpdateCapacityProviderCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateCapacityProviderCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_UpdateClusterCommand = async (output, context) => {
+export const de_SubmitTaskStateChangeCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateClusterCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2389,40 +924,9 @@ export const de_UpdateClusterCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateClusterCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "NamespaceNotFoundException":
-        case "com.amazonaws.ecs#NamespaceNotFoundException":
-            throw await de_NamespaceNotFoundExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_UpdateClusterSettingsCommand = async (output, context) => {
+export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateClusterSettingsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2433,128 +937,87 @@ export const de_UpdateClusterSettingsCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateClusterSettingsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_UpdateContainerAgentCommand = async (output, context) => {
+export const de_UntagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateContainerAgentCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_UpdateContainerAgentResponse(data, context);
+    contents = _json(data);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_UpdateContainerAgentCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const de_UpdateCapacityProviderCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "MissingVersionException":
-        case "com.amazonaws.ecs#MissingVersionException":
-            throw await de_MissingVersionExceptionRes(parsedOutput, context);
-        case "NoUpdateAvailableException":
-        case "com.amazonaws.ecs#NoUpdateAvailableException":
-            throw await de_NoUpdateAvailableExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "UpdateInProgressException":
-        case "com.amazonaws.ecs#UpdateInProgressException":
-            throw await de_UpdateInProgressExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+    return response;
+};
+export const de_UpdateClusterCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_UpdateContainerInstancesStateCommand = async (output, context) => {
+export const de_UpdateClusterSettingsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateContainerInstancesStateCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_UpdateContainerInstancesStateResponse(data, context);
+    contents = _json(data);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_UpdateContainerInstancesStateCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const de_UpdateContainerAgentCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_UpdateContainerAgentResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+    return response;
+};
+export const de_UpdateContainerInstancesStateCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_UpdateContainerInstancesStateResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
 export const de_UpdateServiceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateServiceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2565,58 +1028,9 @@ export const de_UpdateServiceCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateServiceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.ecs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "NamespaceNotFoundException":
-        case "com.amazonaws.ecs#NamespaceNotFoundException":
-            throw await de_NamespaceNotFoundExceptionRes(parsedOutput, context);
-        case "PlatformTaskDefinitionIncompatibilityException":
-        case "com.amazonaws.ecs#PlatformTaskDefinitionIncompatibilityException":
-            throw await de_PlatformTaskDefinitionIncompatibilityExceptionRes(parsedOutput, context);
-        case "PlatformUnknownException":
-        case "com.amazonaws.ecs#PlatformUnknownException":
-            throw await de_PlatformUnknownExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "ServiceNotActiveException":
-        case "com.amazonaws.ecs#ServiceNotActiveException":
-            throw await de_ServiceNotActiveExceptionRes(parsedOutput, context);
-        case "ServiceNotFoundException":
-        case "com.amazonaws.ecs#ServiceNotFoundException":
-            throw await de_ServiceNotFoundExceptionRes(parsedOutput, context);
-        case "UnsupportedFeatureException":
-        case "com.amazonaws.ecs#UnsupportedFeatureException":
-            throw await de_UnsupportedFeatureExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateServicePrimaryTaskSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateServicePrimaryTaskSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2627,52 +1041,9 @@ export const de_UpdateServicePrimaryTaskSetCommand = async (output, context) =>
     };
     return response;
 };
-const de_UpdateServicePrimaryTaskSetCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.ecs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "ServiceNotActiveException":
-        case "com.amazonaws.ecs#ServiceNotActiveException":
-            throw await de_ServiceNotActiveExceptionRes(parsedOutput, context);
-        case "ServiceNotFoundException":
-        case "com.amazonaws.ecs#ServiceNotFoundException":
-            throw await de_ServiceNotFoundExceptionRes(parsedOutput, context);
-        case "TaskSetNotFoundException":
-        case "com.amazonaws.ecs#TaskSetNotFoundException":
-            throw await de_TaskSetNotFoundExceptionRes(parsedOutput, context);
-        case "UnsupportedFeatureException":
-        case "com.amazonaws.ecs#UnsupportedFeatureException":
-            throw await de_UnsupportedFeatureExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateTaskProtectionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateTaskProtectionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2683,46 +1054,9 @@ export const de_UpdateTaskProtectionCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateTaskProtectionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.ecs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.ecs#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.ecs#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.ecs#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServerException":
-        case "com.amazonaws.ecs#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput, context);
-        case "UnsupportedFeatureException":
-        case "com.amazonaws.ecs#UnsupportedFeatureException":
-            throw await de_UnsupportedFeatureExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateTaskSetCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateTaskSetCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2733,40 +1067,91 @@ export const de_UpdateTaskSetCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateTaskSetCommandError = 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 "AccessDeniedException":
-        case "com.amazonaws.ecs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ClientException":
         case "com.amazonaws.ecs#ClientException":
             throw await de_ClientExceptionRes(parsedOutput, context);
-        case "ClusterNotFoundException":
-        case "com.amazonaws.ecs#ClusterNotFoundException":
-            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.ecs#InvalidParameterException":
             throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.ecs#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecs#ServerException":
             throw await de_ServerExceptionRes(parsedOutput, context);
+        case "UpdateInProgressException":
+        case "com.amazonaws.ecs#UpdateInProgressException":
+            throw await de_UpdateInProgressExceptionRes(parsedOutput, context);
+        case "NamespaceNotFoundException":
+        case "com.amazonaws.ecs#NamespaceNotFoundException":
+            throw await de_NamespaceNotFoundExceptionRes(parsedOutput, context);
+        case "AccessDeniedException":
+        case "com.amazonaws.ecs#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ClusterNotFoundException":
+        case "com.amazonaws.ecs#ClusterNotFoundException":
+            throw await de_ClusterNotFoundExceptionRes(parsedOutput, context);
+        case "PlatformTaskDefinitionIncompatibilityException":
+        case "com.amazonaws.ecs#PlatformTaskDefinitionIncompatibilityException":
+            throw await de_PlatformTaskDefinitionIncompatibilityExceptionRes(parsedOutput, context);
+        case "PlatformUnknownException":
+        case "com.amazonaws.ecs#PlatformUnknownException":
+            throw await de_PlatformUnknownExceptionRes(parsedOutput, context);
+        case "UnsupportedFeatureException":
+        case "com.amazonaws.ecs#UnsupportedFeatureException":
+            throw await de_UnsupportedFeatureExceptionRes(parsedOutput, context);
         case "ServiceNotActiveException":
         case "com.amazonaws.ecs#ServiceNotActiveException":
             throw await de_ServiceNotActiveExceptionRes(parsedOutput, context);
         case "ServiceNotFoundException":
         case "com.amazonaws.ecs#ServiceNotFoundException":
             throw await de_ServiceNotFoundExceptionRes(parsedOutput, context);
+        case "TargetNotFoundException":
+        case "com.amazonaws.ecs#TargetNotFoundException":
+            throw await de_TargetNotFoundExceptionRes(parsedOutput, context);
+        case "ClusterContainsContainerInstancesException":
+        case "com.amazonaws.ecs#ClusterContainsContainerInstancesException":
+            throw await de_ClusterContainsContainerInstancesExceptionRes(parsedOutput, context);
+        case "ClusterContainsServicesException":
+        case "com.amazonaws.ecs#ClusterContainsServicesException":
+            throw await de_ClusterContainsServicesExceptionRes(parsedOutput, context);
+        case "ClusterContainsTasksException":
+        case "com.amazonaws.ecs#ClusterContainsTasksException":
+            throw await de_ClusterContainsTasksExceptionRes(parsedOutput, context);
         case "TaskSetNotFoundException":
         case "com.amazonaws.ecs#TaskSetNotFoundException":
             throw await de_TaskSetNotFoundExceptionRes(parsedOutput, context);
-        case "UnsupportedFeatureException":
-        case "com.amazonaws.ecs#UnsupportedFeatureException":
-            throw await de_UnsupportedFeatureExceptionRes(parsedOutput, context);
+        case "TargetNotConnectedException":
+        case "com.amazonaws.ecs#TargetNotConnectedException":
+            throw await de_TargetNotConnectedExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.ecs#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "AttributeLimitExceededException":
+        case "com.amazonaws.ecs#AttributeLimitExceededException":
+            throw await de_AttributeLimitExceededExceptionRes(parsedOutput, context);
+        case "ResourceInUseException":
+        case "com.amazonaws.ecs#ResourceInUseException":
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+        case "BlockedException":
+        case "com.amazonaws.ecs#BlockedException":
+            throw await de_BlockedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.ecs#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "MissingVersionException":
+        case "com.amazonaws.ecs#MissingVersionException":
+            throw await de_MissingVersionExceptionRes(parsedOutput, context);
+        case "NoUpdateAvailableException":
+        case "com.amazonaws.ecs#NoUpdateAvailableException":
+            throw await de_NoUpdateAvailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({