@aws-sdk/client-device-farm 3.504.0 → 3.509.0

package/dist-es/protocols/Aws_json1_1.js

@@ -466,7 +466,7 @@ export const se_UpdateVPCEConfigurationCommand = async (input, context) => {
 };
 export const de_CreateDevicePoolCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateDevicePoolCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -477,37 +477,9 @@ export const de_CreateDevicePoolCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateDevicePoolCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateInstanceProfileCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateInstanceProfileCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -518,37 +490,9 @@ export const de_CreateInstanceProfileCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateInstanceProfileCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateNetworkProfileCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateNetworkProfileCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -559,37 +503,9 @@ export const de_CreateNetworkProfileCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateNetworkProfileCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateProjectCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateProjectCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -600,40 +516,9 @@ export const de_CreateProjectCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateProjectCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        case "TagOperationException":
-        case "com.amazonaws.devicefarm#TagOperationException":
-            throw await de_TagOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateRemoteAccessSessionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateRemoteAccessSessionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -644,37 +529,9 @@ export const de_CreateRemoteAccessSessionCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateRemoteAccessSessionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateTestGridProjectCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateTestGridProjectCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -685,34 +542,9 @@ export const de_CreateTestGridProjectCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateTestGridProjectCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "InternalServiceException":
-        case "com.amazonaws.devicefarm#InternalServiceException":
-            throw await de_InternalServiceExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateTestGridUrlCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateTestGridUrlCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -723,34 +555,9 @@ export const de_CreateTestGridUrlCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateTestGridUrlCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "InternalServiceException":
-        case "com.amazonaws.devicefarm#InternalServiceException":
-            throw await de_InternalServiceExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateUploadCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateUploadCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -761,37 +568,9 @@ export const de_CreateUploadCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateUploadCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateVPCEConfigurationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateVPCEConfigurationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -802,34 +581,9 @@ export const de_CreateVPCEConfigurationCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateVPCEConfigurationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteDevicePoolCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteDevicePoolCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -840,78 +594,22 @@ export const de_DeleteDevicePoolCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteDevicePoolCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteInstanceProfileCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DeleteInstanceProfileCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
+export const de_DeleteInstanceProfileCommand = 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;
 };
-const de_DeleteInstanceProfileCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteNetworkProfileCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteNetworkProfileCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -922,37 +620,9 @@ export const de_DeleteNetworkProfileCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteNetworkProfileCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteProjectCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteProjectCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -963,37 +633,9 @@ export const de_DeleteProjectCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteProjectCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteRemoteAccessSessionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteRemoteAccessSessionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1004,37 +646,9 @@ export const de_DeleteRemoteAccessSessionCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteRemoteAccessSessionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteRunCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteRunCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1045,37 +659,9 @@ export const de_DeleteRunCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteRunCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteTestGridProjectCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteTestGridProjectCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1086,37 +672,9 @@ export const de_DeleteTestGridProjectCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteTestGridProjectCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "CannotDeleteException":
-        case "com.amazonaws.devicefarm#CannotDeleteException":
-            throw await de_CannotDeleteExceptionRes(parsedOutput, context);
-        case "InternalServiceException":
-        case "com.amazonaws.devicefarm#InternalServiceException":
-            throw await de_InternalServiceExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteUploadCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteUploadCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1127,37 +685,9 @@ export const de_DeleteUploadCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteUploadCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteVPCEConfigurationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteVPCEConfigurationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1168,37 +698,9 @@ export const de_DeleteVPCEConfigurationCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteVPCEConfigurationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "InvalidOperationException":
-        case "com.amazonaws.devicefarm#InvalidOperationException":
-            throw await de_InvalidOperationExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetAccountSettingsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetAccountSettingsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1209,78 +711,22 @@ export const de_GetAccountSettingsCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetAccountSettingsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetDeviceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_GetDeviceCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_GetDeviceResult(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
+export const de_GetDeviceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_GetDeviceResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
     return response;
 };
-const de_GetDeviceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetDeviceInstanceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetDeviceInstanceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1291,37 +737,9 @@ export const de_GetDeviceInstanceCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetDeviceInstanceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetDevicePoolCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetDevicePoolCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1332,37 +750,9 @@ export const de_GetDevicePoolCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetDevicePoolCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetDevicePoolCompatibilityCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetDevicePoolCompatibilityCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1373,37 +763,9 @@ export const de_GetDevicePoolCompatibilityCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetDevicePoolCompatibilityCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetInstanceProfileCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetInstanceProfileCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1414,37 +776,9 @@ export const de_GetInstanceProfileCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetInstanceProfileCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetJobCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetJobCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1455,37 +789,9 @@ export const de_GetJobCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetJobCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetNetworkProfileCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetNetworkProfileCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1496,37 +802,9 @@ export const de_GetNetworkProfileCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetNetworkProfileCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetOfferingStatusCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetOfferingStatusCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1537,40 +815,9 @@ export const de_GetOfferingStatusCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetOfferingStatusCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotEligibleException":
-        case "com.amazonaws.devicefarm#NotEligibleException":
-            throw await de_NotEligibleExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetProjectCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetProjectCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1581,37 +828,9 @@ export const de_GetProjectCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetProjectCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetRemoteAccessSessionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetRemoteAccessSessionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1622,37 +841,9 @@ export const de_GetRemoteAccessSessionCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetRemoteAccessSessionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetRunCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetRunCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1663,37 +854,9 @@ export const de_GetRunCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetRunCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetSuiteCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetSuiteCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1704,37 +867,9 @@ export const de_GetSuiteCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetSuiteCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetTestCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetTestCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1745,37 +880,9 @@ export const de_GetTestCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetTestCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetTestGridProjectCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetTestGridProjectCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1786,34 +893,9 @@ export const de_GetTestGridProjectCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetTestGridProjectCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "InternalServiceException":
-        case "com.amazonaws.devicefarm#InternalServiceException":
-            throw await de_InternalServiceExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetTestGridSessionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetTestGridSessionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1824,34 +906,9 @@ export const de_GetTestGridSessionCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetTestGridSessionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "InternalServiceException":
-        case "com.amazonaws.devicefarm#InternalServiceException":
-            throw await de_InternalServiceExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetUploadCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetUploadCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1862,37 +919,9 @@ export const de_GetUploadCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetUploadCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_GetVPCEConfigurationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_GetVPCEConfigurationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1903,34 +932,9 @@ export const de_GetVPCEConfigurationCommand = async (output, context) => {
     };
     return response;
 };
-const de_GetVPCEConfigurationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_InstallToRemoteAccessSessionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_InstallToRemoteAccessSessionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1941,37 +945,9 @@ export const de_InstallToRemoteAccessSessionCommand = async (output, context) =>
     };
     return response;
 };
-const de_InstallToRemoteAccessSessionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListArtifactsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListArtifactsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1982,37 +958,9 @@ export const de_ListArtifactsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListArtifactsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListDeviceInstancesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListDeviceInstancesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2023,37 +971,9 @@ export const de_ListDeviceInstancesCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListDeviceInstancesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListDevicePoolsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListDevicePoolsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2064,37 +984,9 @@ export const de_ListDevicePoolsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListDevicePoolsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListDevicesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListDevicesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2105,37 +997,9 @@ export const de_ListDevicesCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListDevicesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListInstanceProfilesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListInstanceProfilesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2146,37 +1010,9 @@ export const de_ListInstanceProfilesCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListInstanceProfilesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListJobsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListJobsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2187,37 +1023,9 @@ export const de_ListJobsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListJobsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListNetworkProfilesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListNetworkProfilesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2228,37 +1036,9 @@ export const de_ListNetworkProfilesCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListNetworkProfilesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListOfferingPromotionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListOfferingPromotionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2269,40 +1049,9 @@ export const de_ListOfferingPromotionsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListOfferingPromotionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotEligibleException":
-        case "com.amazonaws.devicefarm#NotEligibleException":
-            throw await de_NotEligibleExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListOfferingsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListOfferingsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2313,40 +1062,9 @@ export const de_ListOfferingsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListOfferingsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotEligibleException":
-        case "com.amazonaws.devicefarm#NotEligibleException":
-            throw await de_NotEligibleExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListOfferingTransactionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListOfferingTransactionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2357,40 +1075,9 @@ export const de_ListOfferingTransactionsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListOfferingTransactionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotEligibleException":
-        case "com.amazonaws.devicefarm#NotEligibleException":
-            throw await de_NotEligibleExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListProjectsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListProjectsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2401,37 +1088,9 @@ export const de_ListProjectsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListProjectsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListRemoteAccessSessionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListRemoteAccessSessionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2442,37 +1101,9 @@ export const de_ListRemoteAccessSessionsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListRemoteAccessSessionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListRunsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListRunsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2483,37 +1114,9 @@ export const de_ListRunsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListRunsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListSamplesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListSamplesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2524,37 +1127,9 @@ export const de_ListSamplesCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListSamplesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListSuitesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListSuitesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2565,37 +1140,9 @@ export const de_ListSuitesCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListSuitesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListTagsForResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2606,34 +1153,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 "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "TagOperationException":
-        case "com.amazonaws.devicefarm#TagOperationException":
-            throw await de_TagOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListTestGridProjectsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListTestGridProjectsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2644,31 +1166,9 @@ export const de_ListTestGridProjectsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListTestGridProjectsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "InternalServiceException":
-        case "com.amazonaws.devicefarm#InternalServiceException":
-            throw await de_InternalServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListTestGridSessionActionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListTestGridSessionActionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2679,34 +1179,9 @@ export const de_ListTestGridSessionActionsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListTestGridSessionActionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "InternalServiceException":
-        case "com.amazonaws.devicefarm#InternalServiceException":
-            throw await de_InternalServiceExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListTestGridSessionArtifactsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListTestGridSessionArtifactsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2717,34 +1192,9 @@ export const de_ListTestGridSessionArtifactsCommand = async (output, context) =>
     };
     return response;
 };
-const de_ListTestGridSessionArtifactsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "InternalServiceException":
-        case "com.amazonaws.devicefarm#InternalServiceException":
-            throw await de_InternalServiceExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListTestGridSessionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListTestGridSessionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2755,34 +1205,9 @@ export const de_ListTestGridSessionsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListTestGridSessionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "InternalServiceException":
-        case "com.amazonaws.devicefarm#InternalServiceException":
-            throw await de_InternalServiceExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListTestsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListTestsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2793,37 +1218,9 @@ export const de_ListTestsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListTestsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListUniqueProblemsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListUniqueProblemsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2834,37 +1231,9 @@ export const de_ListUniqueProblemsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListUniqueProblemsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListUploadsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListUploadsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2875,37 +1244,9 @@ export const de_ListUploadsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListUploadsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ListVPCEConfigurationsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListVPCEConfigurationsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2916,31 +1257,9 @@ export const de_ListVPCEConfigurationsCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListVPCEConfigurationsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_PurchaseOfferingCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_PurchaseOfferingCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2951,40 +1270,9 @@ export const de_PurchaseOfferingCommand = async (output, context) => {
     };
     return response;
 };
-const de_PurchaseOfferingCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotEligibleException":
-        case "com.amazonaws.devicefarm#NotEligibleException":
-            throw await de_NotEligibleExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_RenewOfferingCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RenewOfferingCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2995,40 +1283,9 @@ export const de_RenewOfferingCommand = async (output, context) => {
     };
     return response;
 };
-const de_RenewOfferingCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotEligibleException":
-        case "com.amazonaws.devicefarm#NotEligibleException":
-            throw await de_NotEligibleExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ScheduleRunCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ScheduleRunCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3039,40 +1296,9 @@ export const de_ScheduleRunCommand = async (output, context) => {
     };
     return response;
 };
-const de_ScheduleRunCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "IdempotencyException":
-        case "com.amazonaws.devicefarm#IdempotencyException":
-            throw await de_IdempotencyExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_StopJobCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_StopJobCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3083,37 +1309,9 @@ export const de_StopJobCommand = async (output, context) => {
     };
     return response;
 };
-const de_StopJobCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_StopRemoteAccessSessionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_StopRemoteAccessSessionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3124,122 +1322,22 @@ export const de_StopRemoteAccessSessionCommand = async (output, context) => {
     };
     return response;
 };
-const de_StopRemoteAccessSessionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_StopRunCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_StopRunCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
     contents = de_StopRunResult(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_StopRunCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_TagResourceCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    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 "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "TagOperationException":
-        case "com.amazonaws.devicefarm#TagOperationException":
-            throw await de_TagOperationExceptionRes(parsedOutput, context);
-        case "TagPolicyException":
-        case "com.amazonaws.devicefarm#TagPolicyException":
-            throw await de_TagPolicyExceptionRes(parsedOutput, context);
-        case "TooManyTagsException":
-        case "com.amazonaws.devicefarm#TooManyTagsException":
-            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
+        ...contents,
+    };
+    return response;
 };
-export const de_UntagResourceCommand = async (output, context) => {
+export const de_TagResourceCommand = 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 = {};
@@ -3250,34 +1348,22 @@ 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 "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "TagOperationException":
-        case "com.amazonaws.devicefarm#TagOperationException":
-            throw await de_TagOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_UntagResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_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_UpdateDeviceInstanceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateDeviceInstanceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3288,37 +1374,9 @@ export const de_UpdateDeviceInstanceCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateDeviceInstanceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateDevicePoolCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateDevicePoolCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3329,37 +1387,9 @@ export const de_UpdateDevicePoolCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateDevicePoolCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateInstanceProfileCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateInstanceProfileCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3370,37 +1400,9 @@ export const de_UpdateInstanceProfileCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateInstanceProfileCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateNetworkProfileCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateNetworkProfileCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3411,37 +1413,9 @@ export const de_UpdateNetworkProfileCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateNetworkProfileCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateProjectCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateProjectCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3452,37 +1426,9 @@ export const de_UpdateProjectCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateProjectCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateTestGridProjectCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateTestGridProjectCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3493,37 +1439,9 @@ export const de_UpdateTestGridProjectCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateTestGridProjectCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "InternalServiceException":
-        case "com.amazonaws.devicefarm#InternalServiceException":
-            throw await de_InternalServiceExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateUploadCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateUploadCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3534,37 +1452,9 @@ export const de_UpdateUploadCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateUploadCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ArgumentException":
-        case "com.amazonaws.devicefarm#ArgumentException":
-            throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "LimitExceededException":
-        case "com.amazonaws.devicefarm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput, context);
-        case "NotFoundException":
-        case "com.amazonaws.devicefarm#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput, context);
-        case "ServiceAccountException":
-        case "com.amazonaws.devicefarm#ServiceAccountException":
-            throw await de_ServiceAccountExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_UpdateVPCEConfigurationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateVPCEConfigurationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3575,7 +1465,7 @@ export const de_UpdateVPCEConfigurationCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateVPCEConfigurationCommandError = async (output, context) => {
+const de_CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3585,15 +1475,39 @@ const de_UpdateVPCEConfigurationCommandError = async (output, context) => {
         case "ArgumentException":
         case "com.amazonaws.devicefarm#ArgumentException":
             throw await de_ArgumentExceptionRes(parsedOutput, context);
-        case "InvalidOperationException":
-        case "com.amazonaws.devicefarm#InvalidOperationException":
-            throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.devicefarm#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.devicefarm#NotFoundException":
             throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "ServiceAccountException":
         case "com.amazonaws.devicefarm#ServiceAccountException":
             throw await de_ServiceAccountExceptionRes(parsedOutput, context);
+        case "TagOperationException":
+        case "com.amazonaws.devicefarm#TagOperationException":
+            throw await de_TagOperationExceptionRes(parsedOutput, context);
+        case "InternalServiceException":
+        case "com.amazonaws.devicefarm#InternalServiceException":
+            throw await de_InternalServiceExceptionRes(parsedOutput, context);
+        case "CannotDeleteException":
+        case "com.amazonaws.devicefarm#CannotDeleteException":
+            throw await de_CannotDeleteExceptionRes(parsedOutput, context);
+        case "InvalidOperationException":
+        case "com.amazonaws.devicefarm#InvalidOperationException":
+            throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+        case "NotEligibleException":
+        case "com.amazonaws.devicefarm#NotEligibleException":
+            throw await de_NotEligibleExceptionRes(parsedOutput, context);
+        case "IdempotencyException":
+        case "com.amazonaws.devicefarm#IdempotencyException":
+            throw await de_IdempotencyExceptionRes(parsedOutput, context);
+        case "TagPolicyException":
+        case "com.amazonaws.devicefarm#TagPolicyException":
+            throw await de_TagPolicyExceptionRes(parsedOutput, context);
+        case "TooManyTagsException":
+        case "com.amazonaws.devicefarm#TooManyTagsException":
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({