@aws-sdk/client-elasticache 3.504.0 → 3.507.0

package/dist-es/protocols/Aws_query.js

@@ -756,7 +756,7 @@ export const se_TestMigrationCommand = async (input, context) => {
 };
 export const de_AddTagsToResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_AddTagsToResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -767,73 +767,9 @@ export const de_AddTagsToResourceCommand = async (output, context) => {
     };
     return response;
 };
-const de_AddTagsToResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheClusterNotFound":
-        case "com.amazonaws.elasticache#CacheClusterNotFoundFault":
-            throw await de_CacheClusterNotFoundFaultRes(parsedOutput, context);
-        case "CacheParameterGroupNotFound":
-        case "com.amazonaws.elasticache#CacheParameterGroupNotFoundFault":
-            throw await de_CacheParameterGroupNotFoundFaultRes(parsedOutput, context);
-        case "CacheSecurityGroupNotFound":
-        case "com.amazonaws.elasticache#CacheSecurityGroupNotFoundFault":
-            throw await de_CacheSecurityGroupNotFoundFaultRes(parsedOutput, context);
-        case "CacheSubnetGroupNotFoundFault":
-        case "com.amazonaws.elasticache#CacheSubnetGroupNotFoundFault":
-            throw await de_CacheSubnetGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidARN":
-        case "com.amazonaws.elasticache#InvalidARNFault":
-            throw await de_InvalidARNFaultRes(parsedOutput, context);
-        case "InvalidReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidReplicationGroupStateFault":
-            throw await de_InvalidReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidServerlessCacheSnapshotStateFault":
-        case "com.amazonaws.elasticache#InvalidServerlessCacheSnapshotStateFault":
-            throw await de_InvalidServerlessCacheSnapshotStateFaultRes(parsedOutput, context);
-        case "InvalidServerlessCacheStateFault":
-        case "com.amazonaws.elasticache#InvalidServerlessCacheStateFault":
-            throw await de_InvalidServerlessCacheStateFaultRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "ReservedCacheNodeNotFound":
-        case "com.amazonaws.elasticache#ReservedCacheNodeNotFoundFault":
-            throw await de_ReservedCacheNodeNotFoundFaultRes(parsedOutput, context);
-        case "ServerlessCacheNotFoundFault":
-        case "com.amazonaws.elasticache#ServerlessCacheNotFoundFault":
-            throw await de_ServerlessCacheNotFoundFaultRes(parsedOutput, context);
-        case "ServerlessCacheSnapshotNotFoundFault":
-        case "com.amazonaws.elasticache#ServerlessCacheSnapshotNotFoundFault":
-            throw await de_ServerlessCacheSnapshotNotFoundFaultRes(parsedOutput, context);
-        case "SnapshotNotFoundFault":
-        case "com.amazonaws.elasticache#SnapshotNotFoundFault":
-            throw await de_SnapshotNotFoundFaultRes(parsedOutput, context);
-        case "TagQuotaPerResourceExceeded":
-        case "com.amazonaws.elasticache#TagQuotaPerResourceExceeded":
-            throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
-        case "UserGroupNotFound":
-        case "com.amazonaws.elasticache#UserGroupNotFoundFault":
-            throw await de_UserGroupNotFoundFaultRes(parsedOutput, context);
-        case "UserNotFound":
-        case "com.amazonaws.elasticache#UserNotFoundFault":
-            throw await de_UserNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_AuthorizeCacheSecurityGroupIngressCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_AuthorizeCacheSecurityGroupIngressCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -844,40 +780,9 @@ export const de_AuthorizeCacheSecurityGroupIngressCommand = async (output, conte
     };
     return response;
 };
-const de_AuthorizeCacheSecurityGroupIngressCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AuthorizationAlreadyExists":
-        case "com.amazonaws.elasticache#AuthorizationAlreadyExistsFault":
-            throw await de_AuthorizationAlreadyExistsFaultRes(parsedOutput, context);
-        case "CacheSecurityGroupNotFound":
-        case "com.amazonaws.elasticache#CacheSecurityGroupNotFoundFault":
-            throw await de_CacheSecurityGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidCacheSecurityGroupState":
-        case "com.amazonaws.elasticache#InvalidCacheSecurityGroupStateFault":
-            throw await de_InvalidCacheSecurityGroupStateFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_BatchApplyUpdateActionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_BatchApplyUpdateActionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -888,31 +793,9 @@ export const de_BatchApplyUpdateActionCommand = async (output, context) => {
     };
     return response;
 };
-const de_BatchApplyUpdateActionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "ServiceUpdateNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceUpdateNotFoundFault":
-            throw await de_ServiceUpdateNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_BatchStopUpdateActionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_BatchStopUpdateActionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -923,31 +806,9 @@ export const de_BatchStopUpdateActionCommand = async (output, context) => {
     };
     return response;
 };
-const de_BatchStopUpdateActionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "ServiceUpdateNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceUpdateNotFoundFault":
-            throw await de_ServiceUpdateNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CompleteMigrationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CompleteMigrationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -958,34 +819,9 @@ export const de_CompleteMigrationCommand = async (output, context) => {
     };
     return response;
 };
-const de_CompleteMigrationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidReplicationGroupStateFault":
-            throw await de_InvalidReplicationGroupStateFaultRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "ReplicationGroupNotUnderMigrationFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotUnderMigrationFault":
-            throw await de_ReplicationGroupNotUnderMigrationFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CopyServerlessCacheSnapshotCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CopyServerlessCacheSnapshotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -996,49 +832,9 @@ export const de_CopyServerlessCacheSnapshotCommand = async (output, context) =>
     };
     return response;
 };
-const de_CopyServerlessCacheSnapshotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidServerlessCacheSnapshotStateFault":
-        case "com.amazonaws.elasticache#InvalidServerlessCacheSnapshotStateFault":
-            throw await de_InvalidServerlessCacheSnapshotStateFaultRes(parsedOutput, context);
-        case "ServerlessCacheSnapshotAlreadyExistsFault":
-        case "com.amazonaws.elasticache#ServerlessCacheSnapshotAlreadyExistsFault":
-            throw await de_ServerlessCacheSnapshotAlreadyExistsFaultRes(parsedOutput, context);
-        case "ServerlessCacheSnapshotNotFoundFault":
-        case "com.amazonaws.elasticache#ServerlessCacheSnapshotNotFoundFault":
-            throw await de_ServerlessCacheSnapshotNotFoundFaultRes(parsedOutput, context);
-        case "ServerlessCacheSnapshotQuotaExceededFault":
-        case "com.amazonaws.elasticache#ServerlessCacheSnapshotQuotaExceededFault":
-            throw await de_ServerlessCacheSnapshotQuotaExceededFaultRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
-        case "TagQuotaPerResourceExceeded":
-        case "com.amazonaws.elasticache#TagQuotaPerResourceExceeded":
-            throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CopySnapshotCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CopySnapshotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1049,46 +845,9 @@ export const de_CopySnapshotCommand = async (output, context) => {
     };
     return response;
 };
-const de_CopySnapshotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidSnapshotState":
-        case "com.amazonaws.elasticache#InvalidSnapshotStateFault":
-            throw await de_InvalidSnapshotStateFaultRes(parsedOutput, context);
-        case "SnapshotAlreadyExistsFault":
-        case "com.amazonaws.elasticache#SnapshotAlreadyExistsFault":
-            throw await de_SnapshotAlreadyExistsFaultRes(parsedOutput, context);
-        case "SnapshotNotFoundFault":
-        case "com.amazonaws.elasticache#SnapshotNotFoundFault":
-            throw await de_SnapshotNotFoundFaultRes(parsedOutput, context);
-        case "SnapshotQuotaExceededFault":
-        case "com.amazonaws.elasticache#SnapshotQuotaExceededFault":
-            throw await de_SnapshotQuotaExceededFaultRes(parsedOutput, context);
-        case "TagQuotaPerResourceExceeded":
-        case "com.amazonaws.elasticache#TagQuotaPerResourceExceeded":
-            throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateCacheClusterCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateCacheClusterCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1099,114 +858,22 @@ export const de_CreateCacheClusterCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateCacheClusterCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheClusterAlreadyExists":
-        case "com.amazonaws.elasticache#CacheClusterAlreadyExistsFault":
-            throw await de_CacheClusterAlreadyExistsFaultRes(parsedOutput, context);
-        case "CacheParameterGroupNotFound":
-        case "com.amazonaws.elasticache#CacheParameterGroupNotFoundFault":
-            throw await de_CacheParameterGroupNotFoundFaultRes(parsedOutput, context);
-        case "CacheSecurityGroupNotFound":
-        case "com.amazonaws.elasticache#CacheSecurityGroupNotFoundFault":
-            throw await de_CacheSecurityGroupNotFoundFaultRes(parsedOutput, context);
-        case "CacheSubnetGroupNotFoundFault":
-        case "com.amazonaws.elasticache#CacheSubnetGroupNotFoundFault":
-            throw await de_CacheSubnetGroupNotFoundFaultRes(parsedOutput, context);
-        case "ClusterQuotaForCustomerExceeded":
-        case "com.amazonaws.elasticache#ClusterQuotaForCustomerExceededFault":
-            throw await de_ClusterQuotaForCustomerExceededFaultRes(parsedOutput, context);
-        case "InsufficientCacheClusterCapacity":
-        case "com.amazonaws.elasticache#InsufficientCacheClusterCapacityFault":
-            throw await de_InsufficientCacheClusterCapacityFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidReplicationGroupStateFault":
-            throw await de_InvalidReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidVPCNetworkStateFault":
-        case "com.amazonaws.elasticache#InvalidVPCNetworkStateFault":
-            throw await de_InvalidVPCNetworkStateFaultRes(parsedOutput, context);
-        case "NodeQuotaForClusterExceeded":
-        case "com.amazonaws.elasticache#NodeQuotaForClusterExceededFault":
-            throw await de_NodeQuotaForClusterExceededFaultRes(parsedOutput, context);
-        case "NodeQuotaForCustomerExceeded":
-        case "com.amazonaws.elasticache#NodeQuotaForCustomerExceededFault":
-            throw await de_NodeQuotaForCustomerExceededFaultRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "TagQuotaPerResourceExceeded":
-        case "com.amazonaws.elasticache#TagQuotaPerResourceExceeded":
-            throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_CreateCacheParameterGroupCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CreateCacheParameterGroupCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_CreateCacheParameterGroupResult(data.CreateCacheParameterGroupResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
+export const de_CreateCacheParameterGroupCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_CreateCacheParameterGroupResult(data.CreateCacheParameterGroupResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
     return response;
 };
-const de_CreateCacheParameterGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheParameterGroupAlreadyExists":
-        case "com.amazonaws.elasticache#CacheParameterGroupAlreadyExistsFault":
-            throw await de_CacheParameterGroupAlreadyExistsFaultRes(parsedOutput, context);
-        case "CacheParameterGroupQuotaExceeded":
-        case "com.amazonaws.elasticache#CacheParameterGroupQuotaExceededFault":
-            throw await de_CacheParameterGroupQuotaExceededFaultRes(parsedOutput, context);
-        case "InvalidCacheParameterGroupState":
-        case "com.amazonaws.elasticache#InvalidCacheParameterGroupStateFault":
-            throw await de_InvalidCacheParameterGroupStateFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "TagQuotaPerResourceExceeded":
-        case "com.amazonaws.elasticache#TagQuotaPerResourceExceeded":
-            throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateCacheSecurityGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateCacheSecurityGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1217,40 +884,9 @@ export const de_CreateCacheSecurityGroupCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateCacheSecurityGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheSecurityGroupAlreadyExists":
-        case "com.amazonaws.elasticache#CacheSecurityGroupAlreadyExistsFault":
-            throw await de_CacheSecurityGroupAlreadyExistsFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "QuotaExceeded.CacheSecurityGroup":
-        case "com.amazonaws.elasticache#CacheSecurityGroupQuotaExceededFault":
-            throw await de_CacheSecurityGroupQuotaExceededFaultRes(parsedOutput, context);
-        case "TagQuotaPerResourceExceeded":
-        case "com.amazonaws.elasticache#TagQuotaPerResourceExceeded":
-            throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateCacheSubnetGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateCacheSubnetGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1261,43 +897,9 @@ export const de_CreateCacheSubnetGroupCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateCacheSubnetGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheSubnetGroupAlreadyExists":
-        case "com.amazonaws.elasticache#CacheSubnetGroupAlreadyExistsFault":
-            throw await de_CacheSubnetGroupAlreadyExistsFaultRes(parsedOutput, context);
-        case "CacheSubnetGroupQuotaExceeded":
-        case "com.amazonaws.elasticache#CacheSubnetGroupQuotaExceededFault":
-            throw await de_CacheSubnetGroupQuotaExceededFaultRes(parsedOutput, context);
-        case "CacheSubnetQuotaExceededFault":
-        case "com.amazonaws.elasticache#CacheSubnetQuotaExceededFault":
-            throw await de_CacheSubnetQuotaExceededFaultRes(parsedOutput, context);
-        case "InvalidSubnet":
-        case "com.amazonaws.elasticache#InvalidSubnet":
-            throw await de_InvalidSubnetRes(parsedOutput, context);
-        case "SubnetNotAllowedFault":
-        case "com.amazonaws.elasticache#SubnetNotAllowedFault":
-            throw await de_SubnetNotAllowedFaultRes(parsedOutput, context);
-        case "TagQuotaPerResourceExceeded":
-        case "com.amazonaws.elasticache#TagQuotaPerResourceExceeded":
-            throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateGlobalReplicationGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateGlobalReplicationGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1308,40 +910,9 @@ export const de_CreateGlobalReplicationGroupCommand = async (output, context) =>
     };
     return response;
 };
-const de_CreateGlobalReplicationGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "GlobalReplicationGroupAlreadyExistsFault":
-        case "com.amazonaws.elasticache#GlobalReplicationGroupAlreadyExistsFault":
-            throw await de_GlobalReplicationGroupAlreadyExistsFaultRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidReplicationGroupStateFault":
-            throw await de_InvalidReplicationGroupStateFaultRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateReplicationGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateReplicationGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1352,82 +923,9 @@ export const de_CreateReplicationGroupCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateReplicationGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheClusterNotFound":
-        case "com.amazonaws.elasticache#CacheClusterNotFoundFault":
-            throw await de_CacheClusterNotFoundFaultRes(parsedOutput, context);
-        case "CacheParameterGroupNotFound":
-        case "com.amazonaws.elasticache#CacheParameterGroupNotFoundFault":
-            throw await de_CacheParameterGroupNotFoundFaultRes(parsedOutput, context);
-        case "CacheSecurityGroupNotFound":
-        case "com.amazonaws.elasticache#CacheSecurityGroupNotFoundFault":
-            throw await de_CacheSecurityGroupNotFoundFaultRes(parsedOutput, context);
-        case "CacheSubnetGroupNotFoundFault":
-        case "com.amazonaws.elasticache#CacheSubnetGroupNotFoundFault":
-            throw await de_CacheSubnetGroupNotFoundFaultRes(parsedOutput, context);
-        case "ClusterQuotaForCustomerExceeded":
-        case "com.amazonaws.elasticache#ClusterQuotaForCustomerExceededFault":
-            throw await de_ClusterQuotaForCustomerExceededFaultRes(parsedOutput, context);
-        case "GlobalReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#GlobalReplicationGroupNotFoundFault":
-            throw await de_GlobalReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "InsufficientCacheClusterCapacity":
-        case "com.amazonaws.elasticache#InsufficientCacheClusterCapacityFault":
-            throw await de_InsufficientCacheClusterCapacityFaultRes(parsedOutput, context);
-        case "InvalidCacheClusterState":
-        case "com.amazonaws.elasticache#InvalidCacheClusterStateFault":
-            throw await de_InvalidCacheClusterStateFaultRes(parsedOutput, context);
-        case "InvalidGlobalReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidGlobalReplicationGroupStateFault":
-            throw await de_InvalidGlobalReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidUserGroupState":
-        case "com.amazonaws.elasticache#InvalidUserGroupStateFault":
-            throw await de_InvalidUserGroupStateFaultRes(parsedOutput, context);
-        case "InvalidVPCNetworkStateFault":
-        case "com.amazonaws.elasticache#InvalidVPCNetworkStateFault":
-            throw await de_InvalidVPCNetworkStateFaultRes(parsedOutput, context);
-        case "NodeGroupsPerReplicationGroupQuotaExceeded":
-        case "com.amazonaws.elasticache#NodeGroupsPerReplicationGroupQuotaExceededFault":
-            throw await de_NodeGroupsPerReplicationGroupQuotaExceededFaultRes(parsedOutput, context);
-        case "NodeQuotaForClusterExceeded":
-        case "com.amazonaws.elasticache#NodeQuotaForClusterExceededFault":
-            throw await de_NodeQuotaForClusterExceededFaultRes(parsedOutput, context);
-        case "NodeQuotaForCustomerExceeded":
-        case "com.amazonaws.elasticache#NodeQuotaForCustomerExceededFault":
-            throw await de_NodeQuotaForCustomerExceededFaultRes(parsedOutput, context);
-        case "ReplicationGroupAlreadyExists":
-        case "com.amazonaws.elasticache#ReplicationGroupAlreadyExistsFault":
-            throw await de_ReplicationGroupAlreadyExistsFaultRes(parsedOutput, context);
-        case "TagQuotaPerResourceExceeded":
-        case "com.amazonaws.elasticache#TagQuotaPerResourceExceeded":
-            throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
-        case "UserGroupNotFound":
-        case "com.amazonaws.elasticache#UserGroupNotFoundFault":
-            throw await de_UserGroupNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateServerlessCacheCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateServerlessCacheCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1438,58 +936,9 @@ export const de_CreateServerlessCacheCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateServerlessCacheCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidCredentialsException":
-        case "com.amazonaws.elasticache#InvalidCredentialsException":
-            throw await de_InvalidCredentialsExceptionRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidServerlessCacheStateFault":
-        case "com.amazonaws.elasticache#InvalidServerlessCacheStateFault":
-            throw await de_InvalidServerlessCacheStateFaultRes(parsedOutput, context);
-        case "InvalidUserGroupState":
-        case "com.amazonaws.elasticache#InvalidUserGroupStateFault":
-            throw await de_InvalidUserGroupStateFaultRes(parsedOutput, context);
-        case "ServerlessCacheAlreadyExistsFault":
-        case "com.amazonaws.elasticache#ServerlessCacheAlreadyExistsFault":
-            throw await de_ServerlessCacheAlreadyExistsFaultRes(parsedOutput, context);
-        case "ServerlessCacheNotFoundFault":
-        case "com.amazonaws.elasticache#ServerlessCacheNotFoundFault":
-            throw await de_ServerlessCacheNotFoundFaultRes(parsedOutput, context);
-        case "ServerlessCacheQuotaForCustomerExceededFault":
-        case "com.amazonaws.elasticache#ServerlessCacheQuotaForCustomerExceededFault":
-            throw await de_ServerlessCacheQuotaForCustomerExceededFaultRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
-        case "TagQuotaPerResourceExceeded":
-        case "com.amazonaws.elasticache#TagQuotaPerResourceExceeded":
-            throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
-        case "UserGroupNotFound":
-        case "com.amazonaws.elasticache#UserGroupNotFoundFault":
-            throw await de_UserGroupNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateServerlessCacheSnapshotCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateServerlessCacheSnapshotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1500,49 +949,9 @@ export const de_CreateServerlessCacheSnapshotCommand = async (output, context) =
     };
     return response;
 };
-const de_CreateServerlessCacheSnapshotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidServerlessCacheStateFault":
-        case "com.amazonaws.elasticache#InvalidServerlessCacheStateFault":
-            throw await de_InvalidServerlessCacheStateFaultRes(parsedOutput, context);
-        case "ServerlessCacheNotFoundFault":
-        case "com.amazonaws.elasticache#ServerlessCacheNotFoundFault":
-            throw await de_ServerlessCacheNotFoundFaultRes(parsedOutput, context);
-        case "ServerlessCacheSnapshotAlreadyExistsFault":
-        case "com.amazonaws.elasticache#ServerlessCacheSnapshotAlreadyExistsFault":
-            throw await de_ServerlessCacheSnapshotAlreadyExistsFaultRes(parsedOutput, context);
-        case "ServerlessCacheSnapshotQuotaExceededFault":
-        case "com.amazonaws.elasticache#ServerlessCacheSnapshotQuotaExceededFault":
-            throw await de_ServerlessCacheSnapshotQuotaExceededFaultRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
-        case "TagQuotaPerResourceExceeded":
-        case "com.amazonaws.elasticache#TagQuotaPerResourceExceeded":
-            throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateSnapshotCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateSnapshotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1553,55 +962,9 @@ export const de_CreateSnapshotCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateSnapshotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheClusterNotFound":
-        case "com.amazonaws.elasticache#CacheClusterNotFoundFault":
-            throw await de_CacheClusterNotFoundFaultRes(parsedOutput, context);
-        case "InvalidCacheClusterState":
-        case "com.amazonaws.elasticache#InvalidCacheClusterStateFault":
-            throw await de_InvalidCacheClusterStateFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidReplicationGroupStateFault":
-            throw await de_InvalidReplicationGroupStateFaultRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "SnapshotAlreadyExistsFault":
-        case "com.amazonaws.elasticache#SnapshotAlreadyExistsFault":
-            throw await de_SnapshotAlreadyExistsFaultRes(parsedOutput, context);
-        case "SnapshotFeatureNotSupportedFault":
-        case "com.amazonaws.elasticache#SnapshotFeatureNotSupportedFault":
-            throw await de_SnapshotFeatureNotSupportedFaultRes(parsedOutput, context);
-        case "SnapshotQuotaExceededFault":
-        case "com.amazonaws.elasticache#SnapshotQuotaExceededFault":
-            throw await de_SnapshotQuotaExceededFaultRes(parsedOutput, context);
-        case "TagQuotaPerResourceExceeded":
-        case "com.amazonaws.elasticache#TagQuotaPerResourceExceeded":
-            throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateUserCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateUserCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1612,46 +975,9 @@ export const de_CreateUserCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateUserCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "DuplicateUserName":
-        case "com.amazonaws.elasticache#DuplicateUserNameFault":
-            throw await de_DuplicateUserNameFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
-        case "TagQuotaPerResourceExceeded":
-        case "com.amazonaws.elasticache#TagQuotaPerResourceExceeded":
-            throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
-        case "UserAlreadyExists":
-        case "com.amazonaws.elasticache#UserAlreadyExistsFault":
-            throw await de_UserAlreadyExistsFaultRes(parsedOutput, context);
-        case "UserQuotaExceeded":
-        case "com.amazonaws.elasticache#UserQuotaExceededFault":
-            throw await de_UserQuotaExceededFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_CreateUserGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateUserGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1662,49 +988,9 @@ export const de_CreateUserGroupCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateUserGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "DefaultUserRequired":
-        case "com.amazonaws.elasticache#DefaultUserRequired":
-            throw await de_DefaultUserRequiredRes(parsedOutput, context);
-        case "DuplicateUserName":
-        case "com.amazonaws.elasticache#DuplicateUserNameFault":
-            throw await de_DuplicateUserNameFaultRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
-        case "TagQuotaPerResourceExceeded":
-        case "com.amazonaws.elasticache#TagQuotaPerResourceExceeded":
-            throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
-        case "UserGroupAlreadyExists":
-        case "com.amazonaws.elasticache#UserGroupAlreadyExistsFault":
-            throw await de_UserGroupAlreadyExistsFaultRes(parsedOutput, context);
-        case "UserGroupQuotaExceeded":
-        case "com.amazonaws.elasticache#UserGroupQuotaExceededFault":
-            throw await de_UserGroupQuotaExceededFaultRes(parsedOutput, context);
-        case "UserNotFound":
-        case "com.amazonaws.elasticache#UserNotFoundFault":
-            throw await de_UserNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DecreaseNodeGroupsInGlobalReplicationGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DecreaseNodeGroupsInGlobalReplicationGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1715,37 +1001,9 @@ export const de_DecreaseNodeGroupsInGlobalReplicationGroupCommand = async (outpu
     };
     return response;
 };
-const de_DecreaseNodeGroupsInGlobalReplicationGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "GlobalReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#GlobalReplicationGroupNotFoundFault":
-            throw await de_GlobalReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidGlobalReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidGlobalReplicationGroupStateFault":
-            throw await de_InvalidGlobalReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DecreaseReplicaCountCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DecreaseReplicaCountCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1756,111 +1014,22 @@ export const de_DecreaseReplicaCountCommand = async (output, context) => {
     };
     return response;
 };
-const de_DecreaseReplicaCountCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClusterQuotaForCustomerExceeded":
-        case "com.amazonaws.elasticache#ClusterQuotaForCustomerExceededFault":
-            throw await de_ClusterQuotaForCustomerExceededFaultRes(parsedOutput, context);
-        case "InsufficientCacheClusterCapacity":
-        case "com.amazonaws.elasticache#InsufficientCacheClusterCapacityFault":
-            throw await de_InsufficientCacheClusterCapacityFaultRes(parsedOutput, context);
-        case "InvalidCacheClusterState":
-        case "com.amazonaws.elasticache#InvalidCacheClusterStateFault":
-            throw await de_InvalidCacheClusterStateFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidReplicationGroupStateFault":
-            throw await de_InvalidReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidVPCNetworkStateFault":
-        case "com.amazonaws.elasticache#InvalidVPCNetworkStateFault":
-            throw await de_InvalidVPCNetworkStateFaultRes(parsedOutput, context);
-        case "NoOperationFault":
-        case "com.amazonaws.elasticache#NoOperationFault":
-            throw await de_NoOperationFaultRes(parsedOutput, context);
-        case "NodeGroupsPerReplicationGroupQuotaExceeded":
-        case "com.amazonaws.elasticache#NodeGroupsPerReplicationGroupQuotaExceededFault":
-            throw await de_NodeGroupsPerReplicationGroupQuotaExceededFaultRes(parsedOutput, context);
-        case "NodeQuotaForCustomerExceeded":
-        case "com.amazonaws.elasticache#NodeQuotaForCustomerExceededFault":
-            throw await de_NodeQuotaForCustomerExceededFaultRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteCacheClusterCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DeleteCacheClusterCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DeleteCacheClusterResult(data.DeleteCacheClusterResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
+export const de_DeleteCacheClusterCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DeleteCacheClusterResult(data.DeleteCacheClusterResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
     return response;
 };
-const de_DeleteCacheClusterCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheClusterNotFound":
-        case "com.amazonaws.elasticache#CacheClusterNotFoundFault":
-            throw await de_CacheClusterNotFoundFaultRes(parsedOutput, context);
-        case "InvalidCacheClusterState":
-        case "com.amazonaws.elasticache#InvalidCacheClusterStateFault":
-            throw await de_InvalidCacheClusterStateFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "SnapshotAlreadyExistsFault":
-        case "com.amazonaws.elasticache#SnapshotAlreadyExistsFault":
-            throw await de_SnapshotAlreadyExistsFaultRes(parsedOutput, context);
-        case "SnapshotFeatureNotSupportedFault":
-        case "com.amazonaws.elasticache#SnapshotFeatureNotSupportedFault":
-            throw await de_SnapshotFeatureNotSupportedFaultRes(parsedOutput, context);
-        case "SnapshotQuotaExceededFault":
-        case "com.amazonaws.elasticache#SnapshotQuotaExceededFault":
-            throw await de_SnapshotQuotaExceededFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteCacheParameterGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteCacheParameterGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -1868,37 +1037,9 @@ export const de_DeleteCacheParameterGroupCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteCacheParameterGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheParameterGroupNotFound":
-        case "com.amazonaws.elasticache#CacheParameterGroupNotFoundFault":
-            throw await de_CacheParameterGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidCacheParameterGroupState":
-        case "com.amazonaws.elasticache#InvalidCacheParameterGroupStateFault":
-            throw await de_InvalidCacheParameterGroupStateFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteCacheSecurityGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteCacheSecurityGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -1906,37 +1047,9 @@ export const de_DeleteCacheSecurityGroupCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteCacheSecurityGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheSecurityGroupNotFound":
-        case "com.amazonaws.elasticache#CacheSecurityGroupNotFoundFault":
-            throw await de_CacheSecurityGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidCacheSecurityGroupState":
-        case "com.amazonaws.elasticache#InvalidCacheSecurityGroupStateFault":
-            throw await de_InvalidCacheSecurityGroupStateFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteCacheSubnetGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteCacheSubnetGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -1944,31 +1057,9 @@ export const de_DeleteCacheSubnetGroupCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteCacheSubnetGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheSubnetGroupInUse":
-        case "com.amazonaws.elasticache#CacheSubnetGroupInUse":
-            throw await de_CacheSubnetGroupInUseRes(parsedOutput, context);
-        case "CacheSubnetGroupNotFoundFault":
-        case "com.amazonaws.elasticache#CacheSubnetGroupNotFoundFault":
-            throw await de_CacheSubnetGroupNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteGlobalReplicationGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteGlobalReplicationGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1979,34 +1070,9 @@ export const de_DeleteGlobalReplicationGroupCommand = async (output, context) =>
     };
     return response;
 };
-const de_DeleteGlobalReplicationGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "GlobalReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#GlobalReplicationGroupNotFoundFault":
-            throw await de_GlobalReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidGlobalReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidGlobalReplicationGroupStateFault":
-            throw await de_InvalidGlobalReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteReplicationGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteReplicationGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2017,46 +1083,9 @@ export const de_DeleteReplicationGroupCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteReplicationGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidReplicationGroupStateFault":
-            throw await de_InvalidReplicationGroupStateFaultRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "SnapshotAlreadyExistsFault":
-        case "com.amazonaws.elasticache#SnapshotAlreadyExistsFault":
-            throw await de_SnapshotAlreadyExistsFaultRes(parsedOutput, context);
-        case "SnapshotFeatureNotSupportedFault":
-        case "com.amazonaws.elasticache#SnapshotFeatureNotSupportedFault":
-            throw await de_SnapshotFeatureNotSupportedFaultRes(parsedOutput, context);
-        case "SnapshotQuotaExceededFault":
-        case "com.amazonaws.elasticache#SnapshotQuotaExceededFault":
-            throw await de_SnapshotQuotaExceededFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteServerlessCacheCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteServerlessCacheCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2067,46 +1096,9 @@ export const de_DeleteServerlessCacheCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteServerlessCacheCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidCredentialsException":
-        case "com.amazonaws.elasticache#InvalidCredentialsException":
-            throw await de_InvalidCredentialsExceptionRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidServerlessCacheStateFault":
-        case "com.amazonaws.elasticache#InvalidServerlessCacheStateFault":
-            throw await de_InvalidServerlessCacheStateFaultRes(parsedOutput, context);
-        case "ServerlessCacheNotFoundFault":
-        case "com.amazonaws.elasticache#ServerlessCacheNotFoundFault":
-            throw await de_ServerlessCacheNotFoundFaultRes(parsedOutput, context);
-        case "ServerlessCacheSnapshotAlreadyExistsFault":
-        case "com.amazonaws.elasticache#ServerlessCacheSnapshotAlreadyExistsFault":
-            throw await de_ServerlessCacheSnapshotAlreadyExistsFaultRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteServerlessCacheSnapshotCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteServerlessCacheSnapshotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2117,37 +1109,9 @@ export const de_DeleteServerlessCacheSnapshotCommand = async (output, context) =
     };
     return response;
 };
-const de_DeleteServerlessCacheSnapshotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidServerlessCacheSnapshotStateFault":
-        case "com.amazonaws.elasticache#InvalidServerlessCacheSnapshotStateFault":
-            throw await de_InvalidServerlessCacheSnapshotStateFaultRes(parsedOutput, context);
-        case "ServerlessCacheSnapshotNotFoundFault":
-        case "com.amazonaws.elasticache#ServerlessCacheSnapshotNotFoundFault":
-            throw await de_ServerlessCacheSnapshotNotFoundFaultRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteSnapshotCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteSnapshotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2158,37 +1122,9 @@ export const de_DeleteSnapshotCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteSnapshotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidSnapshotState":
-        case "com.amazonaws.elasticache#InvalidSnapshotStateFault":
-            throw await de_InvalidSnapshotStateFaultRes(parsedOutput, context);
-        case "SnapshotNotFoundFault":
-        case "com.amazonaws.elasticache#SnapshotNotFoundFault":
-            throw await de_SnapshotNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteUserCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteUserCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2199,40 +1135,9 @@ export const de_DeleteUserCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteUserCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "DefaultUserAssociatedToUserGroup":
-        case "com.amazonaws.elasticache#DefaultUserAssociatedToUserGroupFault":
-            throw await de_DefaultUserAssociatedToUserGroupFaultRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidUserState":
-        case "com.amazonaws.elasticache#InvalidUserStateFault":
-            throw await de_InvalidUserStateFaultRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
-        case "UserNotFound":
-        case "com.amazonaws.elasticache#UserNotFoundFault":
-            throw await de_UserNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DeleteUserGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteUserGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2243,37 +1148,9 @@ export const de_DeleteUserGroupCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteUserGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidUserGroupState":
-        case "com.amazonaws.elasticache#InvalidUserGroupStateFault":
-            throw await de_InvalidUserGroupStateFaultRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
-        case "UserGroupNotFound":
-        case "com.amazonaws.elasticache#UserGroupNotFoundFault":
-            throw await de_UserGroupNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeCacheClustersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeCacheClustersCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2284,34 +1161,9 @@ export const de_DescribeCacheClustersCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeCacheClustersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheClusterNotFound":
-        case "com.amazonaws.elasticache#CacheClusterNotFoundFault":
-            throw await de_CacheClusterNotFoundFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeCacheEngineVersionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeCacheEngineVersionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2322,22 +1174,9 @@ export const de_DescribeCacheEngineVersionsCommand = async (output, context) =>
     };
     return response;
 };
-const de_DescribeCacheEngineVersionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    const parsedBody = parsedOutput.body;
-    return throwDefaultError({
-        output,
-        parsedBody: parsedBody.Error,
-        errorCode,
-    });
-};
 export const de_DescribeCacheParameterGroupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeCacheParameterGroupsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2348,34 +1187,9 @@ export const de_DescribeCacheParameterGroupsCommand = async (output, context) =>
     };
     return response;
 };
-const de_DescribeCacheParameterGroupsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheParameterGroupNotFound":
-        case "com.amazonaws.elasticache#CacheParameterGroupNotFoundFault":
-            throw await de_CacheParameterGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeCacheParametersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeCacheParametersCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2386,34 +1200,9 @@ export const de_DescribeCacheParametersCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeCacheParametersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheParameterGroupNotFound":
-        case "com.amazonaws.elasticache#CacheParameterGroupNotFoundFault":
-            throw await de_CacheParameterGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeCacheSecurityGroupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeCacheSecurityGroupsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2424,34 +1213,9 @@ export const de_DescribeCacheSecurityGroupsCommand = async (output, context) =>
     };
     return response;
 };
-const de_DescribeCacheSecurityGroupsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheSecurityGroupNotFound":
-        case "com.amazonaws.elasticache#CacheSecurityGroupNotFoundFault":
-            throw await de_CacheSecurityGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeCacheSubnetGroupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeCacheSubnetGroupsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2462,28 +1226,9 @@ export const de_DescribeCacheSubnetGroupsCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeCacheSubnetGroupsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheSubnetGroupNotFoundFault":
-        case "com.amazonaws.elasticache#CacheSubnetGroupNotFoundFault":
-            throw await de_CacheSubnetGroupNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeEngineDefaultParametersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeEngineDefaultParametersCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2494,31 +1239,9 @@ export const de_DescribeEngineDefaultParametersCommand = async (output, context)
     };
     return response;
 };
-const de_DescribeEngineDefaultParametersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeEventsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeEventsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2529,31 +1252,9 @@ export const de_DescribeEventsCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeEventsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeGlobalReplicationGroupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeGlobalReplicationGroupsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2564,34 +1265,9 @@ export const de_DescribeGlobalReplicationGroupsCommand = async (output, context)
     };
     return response;
 };
-const de_DescribeGlobalReplicationGroupsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "GlobalReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#GlobalReplicationGroupNotFoundFault":
-            throw await de_GlobalReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeReplicationGroupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeReplicationGroupsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2602,34 +1278,9 @@ export const de_DescribeReplicationGroupsCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeReplicationGroupsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeReservedCacheNodesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeReservedCacheNodesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2640,34 +1291,9 @@ export const de_DescribeReservedCacheNodesCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeReservedCacheNodesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "ReservedCacheNodeNotFound":
-        case "com.amazonaws.elasticache#ReservedCacheNodeNotFoundFault":
-            throw await de_ReservedCacheNodeNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeReservedCacheNodesOfferingsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeReservedCacheNodesOfferingsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2678,34 +1304,9 @@ export const de_DescribeReservedCacheNodesOfferingsCommand = async (output, cont
     };
     return response;
 };
-const de_DescribeReservedCacheNodesOfferingsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "ReservedCacheNodesOfferingNotFound":
-        case "com.amazonaws.elasticache#ReservedCacheNodesOfferingNotFoundFault":
-            throw await de_ReservedCacheNodesOfferingNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeServerlessCachesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeServerlessCachesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2716,34 +1317,9 @@ export const de_DescribeServerlessCachesCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeServerlessCachesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "ServerlessCacheNotFoundFault":
-        case "com.amazonaws.elasticache#ServerlessCacheNotFoundFault":
-            throw await de_ServerlessCacheNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeServerlessCacheSnapshotsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeServerlessCacheSnapshotsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2754,37 +1330,9 @@ export const de_DescribeServerlessCacheSnapshotsCommand = async (output, context
     };
     return response;
 };
-const de_DescribeServerlessCacheSnapshotsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "ServerlessCacheNotFoundFault":
-        case "com.amazonaws.elasticache#ServerlessCacheNotFoundFault":
-            throw await de_ServerlessCacheNotFoundFaultRes(parsedOutput, context);
-        case "ServerlessCacheSnapshotNotFoundFault":
-        case "com.amazonaws.elasticache#ServerlessCacheSnapshotNotFoundFault":
-            throw await de_ServerlessCacheSnapshotNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeServiceUpdatesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeServiceUpdatesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2795,34 +1343,9 @@ export const de_DescribeServiceUpdatesCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeServiceUpdatesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "ServiceUpdateNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceUpdateNotFoundFault":
-            throw await de_ServiceUpdateNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeSnapshotsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeSnapshotsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2833,37 +1356,9 @@ export const de_DescribeSnapshotsCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeSnapshotsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheClusterNotFound":
-        case "com.amazonaws.elasticache#CacheClusterNotFoundFault":
-            throw await de_CacheClusterNotFoundFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "SnapshotNotFoundFault":
-        case "com.amazonaws.elasticache#SnapshotNotFoundFault":
-            throw await de_SnapshotNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeUpdateActionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeUpdateActionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2874,31 +1369,9 @@ export const de_DescribeUpdateActionsCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeUpdateActionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeUserGroupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeUserGroupsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2909,34 +1382,9 @@ export const de_DescribeUserGroupsCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeUserGroupsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
-        case "UserGroupNotFound":
-        case "com.amazonaws.elasticache#UserGroupNotFoundFault":
-            throw await de_UserGroupNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DescribeUsersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeUsersCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2947,34 +1395,9 @@ export const de_DescribeUsersCommand = async (output, context) => {
     };
     return response;
 };
-const de_DescribeUsersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
-        case "UserNotFound":
-        case "com.amazonaws.elasticache#UserNotFoundFault":
-            throw await de_UserNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_DisassociateGlobalReplicationGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DisassociateGlobalReplicationGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2985,37 +1408,9 @@ export const de_DisassociateGlobalReplicationGroupCommand = async (output, conte
     };
     return response;
 };
-const de_DisassociateGlobalReplicationGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "GlobalReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#GlobalReplicationGroupNotFoundFault":
-            throw await de_GlobalReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidGlobalReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidGlobalReplicationGroupStateFault":
-            throw await de_InvalidGlobalReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_ExportServerlessCacheSnapshotCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ExportServerlessCacheSnapshotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3026,37 +1421,9 @@ export const de_ExportServerlessCacheSnapshotCommand = async (output, context) =
     };
     return response;
 };
-const de_ExportServerlessCacheSnapshotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidServerlessCacheSnapshotStateFault":
-        case "com.amazonaws.elasticache#InvalidServerlessCacheSnapshotStateFault":
-            throw await de_InvalidServerlessCacheSnapshotStateFaultRes(parsedOutput, context);
-        case "ServerlessCacheSnapshotNotFoundFault":
-        case "com.amazonaws.elasticache#ServerlessCacheSnapshotNotFoundFault":
-            throw await de_ServerlessCacheSnapshotNotFoundFaultRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_FailoverGlobalReplicationGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_FailoverGlobalReplicationGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3067,37 +1434,9 @@ export const de_FailoverGlobalReplicationGroupCommand = async (output, context)
     };
     return response;
 };
-const de_FailoverGlobalReplicationGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "GlobalReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#GlobalReplicationGroupNotFoundFault":
-            throw await de_GlobalReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidGlobalReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidGlobalReplicationGroupStateFault":
-            throw await de_InvalidGlobalReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_IncreaseNodeGroupsInGlobalReplicationGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_IncreaseNodeGroupsInGlobalReplicationGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3108,34 +1447,9 @@ export const de_IncreaseNodeGroupsInGlobalReplicationGroupCommand = async (outpu
     };
     return response;
 };
-const de_IncreaseNodeGroupsInGlobalReplicationGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "GlobalReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#GlobalReplicationGroupNotFoundFault":
-            throw await de_GlobalReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidGlobalReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidGlobalReplicationGroupStateFault":
-            throw await de_InvalidGlobalReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_IncreaseReplicaCountCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_IncreaseReplicaCountCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3146,61 +1460,9 @@ export const de_IncreaseReplicaCountCommand = async (output, context) => {
     };
     return response;
 };
-const de_IncreaseReplicaCountCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClusterQuotaForCustomerExceeded":
-        case "com.amazonaws.elasticache#ClusterQuotaForCustomerExceededFault":
-            throw await de_ClusterQuotaForCustomerExceededFaultRes(parsedOutput, context);
-        case "InsufficientCacheClusterCapacity":
-        case "com.amazonaws.elasticache#InsufficientCacheClusterCapacityFault":
-            throw await de_InsufficientCacheClusterCapacityFaultRes(parsedOutput, context);
-        case "InvalidCacheClusterState":
-        case "com.amazonaws.elasticache#InvalidCacheClusterStateFault":
-            throw await de_InvalidCacheClusterStateFaultRes(parsedOutput, context);
-        case "InvalidKMSKeyFault":
-        case "com.amazonaws.elasticache#InvalidKMSKeyFault":
-            throw await de_InvalidKMSKeyFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidReplicationGroupStateFault":
-            throw await de_InvalidReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidVPCNetworkStateFault":
-        case "com.amazonaws.elasticache#InvalidVPCNetworkStateFault":
-            throw await de_InvalidVPCNetworkStateFaultRes(parsedOutput, context);
-        case "NoOperationFault":
-        case "com.amazonaws.elasticache#NoOperationFault":
-            throw await de_NoOperationFaultRes(parsedOutput, context);
-        case "NodeGroupsPerReplicationGroupQuotaExceeded":
-        case "com.amazonaws.elasticache#NodeGroupsPerReplicationGroupQuotaExceededFault":
-            throw await de_NodeGroupsPerReplicationGroupQuotaExceededFaultRes(parsedOutput, context);
-        case "NodeQuotaForCustomerExceeded":
-        case "com.amazonaws.elasticache#NodeQuotaForCustomerExceededFault":
-            throw await de_NodeQuotaForCustomerExceededFaultRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 export const de_ListAllowedNodeTypeModificationsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListAllowedNodeTypeModificationsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3211,952 +1473,485 @@ export const de_ListAllowedNodeTypeModificationsCommand = async (output, context
     };
     return response;
 };
-const de_ListAllowedNodeTypeModificationsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const de_ListTagsForResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_TagListMessage(data.ListTagsForResourceResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheClusterNotFound":
-        case "com.amazonaws.elasticache#CacheClusterNotFoundFault":
-            throw await de_CacheClusterNotFoundFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
+    return response;
+};
+export const de_ModifyCacheClusterCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ModifyCacheClusterResult(data.ModifyCacheClusterResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_ListTagsForResourceCommand = async (output, context) => {
+export const de_ModifyCacheParameterGroupCommand = 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 = {};
-    contents = de_TagListMessage(data.ListTagsForResourceResult, context);
+    contents = de_CacheParameterGroupNameMessage(data.ModifyCacheParameterGroupResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ListTagsForResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const de_ModifyCacheSubnetGroupCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ModifyCacheSubnetGroupResult(data.ModifyCacheSubnetGroupResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheClusterNotFound":
-        case "com.amazonaws.elasticache#CacheClusterNotFoundFault":
-            throw await de_CacheClusterNotFoundFaultRes(parsedOutput, context);
-        case "CacheParameterGroupNotFound":
-        case "com.amazonaws.elasticache#CacheParameterGroupNotFoundFault":
-            throw await de_CacheParameterGroupNotFoundFaultRes(parsedOutput, context);
-        case "CacheSecurityGroupNotFound":
-        case "com.amazonaws.elasticache#CacheSecurityGroupNotFoundFault":
-            throw await de_CacheSecurityGroupNotFoundFaultRes(parsedOutput, context);
-        case "CacheSubnetGroupNotFoundFault":
-        case "com.amazonaws.elasticache#CacheSubnetGroupNotFoundFault":
-            throw await de_CacheSubnetGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidARN":
-        case "com.amazonaws.elasticache#InvalidARNFault":
-            throw await de_InvalidARNFaultRes(parsedOutput, context);
-        case "InvalidReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidReplicationGroupStateFault":
-            throw await de_InvalidReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidServerlessCacheSnapshotStateFault":
-        case "com.amazonaws.elasticache#InvalidServerlessCacheSnapshotStateFault":
-            throw await de_InvalidServerlessCacheSnapshotStateFaultRes(parsedOutput, context);
-        case "InvalidServerlessCacheStateFault":
-        case "com.amazonaws.elasticache#InvalidServerlessCacheStateFault":
-            throw await de_InvalidServerlessCacheStateFaultRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "ReservedCacheNodeNotFound":
-        case "com.amazonaws.elasticache#ReservedCacheNodeNotFoundFault":
-            throw await de_ReservedCacheNodeNotFoundFaultRes(parsedOutput, context);
-        case "ServerlessCacheNotFoundFault":
-        case "com.amazonaws.elasticache#ServerlessCacheNotFoundFault":
-            throw await de_ServerlessCacheNotFoundFaultRes(parsedOutput, context);
-        case "ServerlessCacheSnapshotNotFoundFault":
-        case "com.amazonaws.elasticache#ServerlessCacheSnapshotNotFoundFault":
-            throw await de_ServerlessCacheSnapshotNotFoundFaultRes(parsedOutput, context);
-        case "SnapshotNotFoundFault":
-        case "com.amazonaws.elasticache#SnapshotNotFoundFault":
-            throw await de_SnapshotNotFoundFaultRes(parsedOutput, context);
-        case "UserGroupNotFound":
-        case "com.amazonaws.elasticache#UserGroupNotFoundFault":
-            throw await de_UserGroupNotFoundFaultRes(parsedOutput, context);
-        case "UserNotFound":
-        case "com.amazonaws.elasticache#UserNotFoundFault":
-            throw await de_UserNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
+    return response;
 };
-export const de_ModifyCacheClusterCommand = async (output, context) => {
+export const de_ModifyGlobalReplicationGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ModifyCacheClusterCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_ModifyCacheClusterResult(data.ModifyCacheClusterResult, context);
+    contents = de_ModifyGlobalReplicationGroupResult(data.ModifyGlobalReplicationGroupResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ModifyCacheClusterCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheClusterNotFound":
-        case "com.amazonaws.elasticache#CacheClusterNotFoundFault":
-            throw await de_CacheClusterNotFoundFaultRes(parsedOutput, context);
-        case "CacheParameterGroupNotFound":
-        case "com.amazonaws.elasticache#CacheParameterGroupNotFoundFault":
-            throw await de_CacheParameterGroupNotFoundFaultRes(parsedOutput, context);
-        case "CacheSecurityGroupNotFound":
-        case "com.amazonaws.elasticache#CacheSecurityGroupNotFoundFault":
-            throw await de_CacheSecurityGroupNotFoundFaultRes(parsedOutput, context);
-        case "InsufficientCacheClusterCapacity":
-        case "com.amazonaws.elasticache#InsufficientCacheClusterCapacityFault":
-            throw await de_InsufficientCacheClusterCapacityFaultRes(parsedOutput, context);
-        case "InvalidCacheClusterState":
-        case "com.amazonaws.elasticache#InvalidCacheClusterStateFault":
-            throw await de_InvalidCacheClusterStateFaultRes(parsedOutput, context);
-        case "InvalidCacheSecurityGroupState":
-        case "com.amazonaws.elasticache#InvalidCacheSecurityGroupStateFault":
-            throw await de_InvalidCacheSecurityGroupStateFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidVPCNetworkStateFault":
-        case "com.amazonaws.elasticache#InvalidVPCNetworkStateFault":
-            throw await de_InvalidVPCNetworkStateFaultRes(parsedOutput, context);
-        case "NodeQuotaForClusterExceeded":
-        case "com.amazonaws.elasticache#NodeQuotaForClusterExceededFault":
-            throw await de_NodeQuotaForClusterExceededFaultRes(parsedOutput, context);
-        case "NodeQuotaForCustomerExceeded":
-        case "com.amazonaws.elasticache#NodeQuotaForCustomerExceededFault":
-            throw await de_NodeQuotaForCustomerExceededFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
+export const de_ModifyReplicationGroupCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ModifyReplicationGroupResult(data.ModifyReplicationGroupResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_ModifyCacheParameterGroupCommand = async (output, context) => {
+export const de_ModifyReplicationGroupShardConfigurationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ModifyCacheParameterGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_CacheParameterGroupNameMessage(data.ModifyCacheParameterGroupResult, context);
+    contents = de_ModifyReplicationGroupShardConfigurationResult(data.ModifyReplicationGroupShardConfigurationResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ModifyCacheParameterGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheParameterGroupNotFound":
-        case "com.amazonaws.elasticache#CacheParameterGroupNotFoundFault":
-            throw await de_CacheParameterGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidCacheParameterGroupState":
-        case "com.amazonaws.elasticache#InvalidCacheParameterGroupStateFault":
-            throw await de_InvalidCacheParameterGroupStateFaultRes(parsedOutput, context);
-        case "InvalidGlobalReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidGlobalReplicationGroupStateFault":
-            throw await de_InvalidGlobalReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
+export const de_ModifyServerlessCacheCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ModifyServerlessCacheResponse(data.ModifyServerlessCacheResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_ModifyCacheSubnetGroupCommand = async (output, context) => {
+export const de_ModifyUserCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ModifyCacheSubnetGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_ModifyCacheSubnetGroupResult(data.ModifyCacheSubnetGroupResult, context);
+    contents = de_User(data.ModifyUserResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ModifyCacheSubnetGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const de_ModifyUserGroupCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_UserGroup(data.ModifyUserGroupResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheSubnetGroupNotFoundFault":
-        case "com.amazonaws.elasticache#CacheSubnetGroupNotFoundFault":
-            throw await de_CacheSubnetGroupNotFoundFaultRes(parsedOutput, context);
-        case "CacheSubnetQuotaExceededFault":
-        case "com.amazonaws.elasticache#CacheSubnetQuotaExceededFault":
-            throw await de_CacheSubnetQuotaExceededFaultRes(parsedOutput, context);
-        case "InvalidSubnet":
-        case "com.amazonaws.elasticache#InvalidSubnet":
-            throw await de_InvalidSubnetRes(parsedOutput, context);
-        case "SubnetInUse":
-        case "com.amazonaws.elasticache#SubnetInUse":
-            throw await de_SubnetInUseRes(parsedOutput, context);
-        case "SubnetNotAllowedFault":
-        case "com.amazonaws.elasticache#SubnetNotAllowedFault":
-            throw await de_SubnetNotAllowedFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
+    return response;
+};
+export const de_PurchaseReservedCacheNodesOfferingCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_PurchaseReservedCacheNodesOfferingResult(data.PurchaseReservedCacheNodesOfferingResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_ModifyGlobalReplicationGroupCommand = async (output, context) => {
+export const de_RebalanceSlotsInGlobalReplicationGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ModifyGlobalReplicationGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_ModifyGlobalReplicationGroupResult(data.ModifyGlobalReplicationGroupResult, context);
+    contents = de_RebalanceSlotsInGlobalReplicationGroupResult(data.RebalanceSlotsInGlobalReplicationGroupResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ModifyGlobalReplicationGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const de_RebootCacheClusterCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_RebootCacheClusterResult(data.RebootCacheClusterResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "GlobalReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#GlobalReplicationGroupNotFoundFault":
-            throw await de_GlobalReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidGlobalReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidGlobalReplicationGroupStateFault":
-            throw await de_InvalidGlobalReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
+    return response;
+};
+export const de_RemoveTagsFromResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_TagListMessage(data.RemoveTagsFromResourceResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_ModifyReplicationGroupCommand = async (output, context) => {
+export const de_ResetCacheParameterGroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ModifyReplicationGroupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_ModifyReplicationGroupResult(data.ModifyReplicationGroupResult, context);
+    contents = de_CacheParameterGroupNameMessage(data.ResetCacheParameterGroupResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ModifyReplicationGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const de_RevokeCacheSecurityGroupIngressCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_RevokeCacheSecurityGroupIngressResult(data.RevokeCacheSecurityGroupIngressResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheClusterNotFound":
-        case "com.amazonaws.elasticache#CacheClusterNotFoundFault":
-            throw await de_CacheClusterNotFoundFaultRes(parsedOutput, context);
-        case "CacheParameterGroupNotFound":
-        case "com.amazonaws.elasticache#CacheParameterGroupNotFoundFault":
-            throw await de_CacheParameterGroupNotFoundFaultRes(parsedOutput, context);
-        case "CacheSecurityGroupNotFound":
-        case "com.amazonaws.elasticache#CacheSecurityGroupNotFoundFault":
-            throw await de_CacheSecurityGroupNotFoundFaultRes(parsedOutput, context);
-        case "InsufficientCacheClusterCapacity":
-        case "com.amazonaws.elasticache#InsufficientCacheClusterCapacityFault":
-            throw await de_InsufficientCacheClusterCapacityFaultRes(parsedOutput, context);
-        case "InvalidCacheClusterState":
-        case "com.amazonaws.elasticache#InvalidCacheClusterStateFault":
-            throw await de_InvalidCacheClusterStateFaultRes(parsedOutput, context);
-        case "InvalidCacheSecurityGroupState":
-        case "com.amazonaws.elasticache#InvalidCacheSecurityGroupStateFault":
-            throw await de_InvalidCacheSecurityGroupStateFaultRes(parsedOutput, context);
-        case "InvalidKMSKeyFault":
-        case "com.amazonaws.elasticache#InvalidKMSKeyFault":
-            throw await de_InvalidKMSKeyFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidReplicationGroupStateFault":
-            throw await de_InvalidReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidUserGroupState":
-        case "com.amazonaws.elasticache#InvalidUserGroupStateFault":
-            throw await de_InvalidUserGroupStateFaultRes(parsedOutput, context);
-        case "InvalidVPCNetworkStateFault":
-        case "com.amazonaws.elasticache#InvalidVPCNetworkStateFault":
-            throw await de_InvalidVPCNetworkStateFaultRes(parsedOutput, context);
-        case "NodeQuotaForClusterExceeded":
-        case "com.amazonaws.elasticache#NodeQuotaForClusterExceededFault":
-            throw await de_NodeQuotaForClusterExceededFaultRes(parsedOutput, context);
-        case "NodeQuotaForCustomerExceeded":
-        case "com.amazonaws.elasticache#NodeQuotaForCustomerExceededFault":
-            throw await de_NodeQuotaForCustomerExceededFaultRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "UserGroupNotFound":
-        case "com.amazonaws.elasticache#UserGroupNotFoundFault":
-            throw await de_UserGroupNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
+    return response;
 };
-export const de_ModifyReplicationGroupShardConfigurationCommand = async (output, context) => {
+export const de_StartMigrationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ModifyReplicationGroupShardConfigurationCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_ModifyReplicationGroupShardConfigurationResult(data.ModifyReplicationGroupShardConfigurationResult, context);
+    contents = de_StartMigrationResponse(data.StartMigrationResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ModifyReplicationGroupShardConfigurationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InsufficientCacheClusterCapacity":
-        case "com.amazonaws.elasticache#InsufficientCacheClusterCapacityFault":
-            throw await de_InsufficientCacheClusterCapacityFaultRes(parsedOutput, context);
-        case "InvalidCacheClusterState":
-        case "com.amazonaws.elasticache#InvalidCacheClusterStateFault":
-            throw await de_InvalidCacheClusterStateFaultRes(parsedOutput, context);
-        case "InvalidKMSKeyFault":
-        case "com.amazonaws.elasticache#InvalidKMSKeyFault":
-            throw await de_InvalidKMSKeyFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidReplicationGroupStateFault":
-            throw await de_InvalidReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidVPCNetworkStateFault":
-        case "com.amazonaws.elasticache#InvalidVPCNetworkStateFault":
-            throw await de_InvalidVPCNetworkStateFaultRes(parsedOutput, context);
-        case "NodeGroupsPerReplicationGroupQuotaExceeded":
-        case "com.amazonaws.elasticache#NodeGroupsPerReplicationGroupQuotaExceededFault":
-            throw await de_NodeGroupsPerReplicationGroupQuotaExceededFaultRes(parsedOutput, context);
-        case "NodeQuotaForCustomerExceeded":
-        case "com.amazonaws.elasticache#NodeQuotaForCustomerExceededFault":
-            throw await de_NodeQuotaForCustomerExceededFaultRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
+export const de_TestFailoverCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_TestFailoverResult(data.TestFailoverResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_ModifyServerlessCacheCommand = async (output, context) => {
+export const de_TestMigrationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ModifyServerlessCacheCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_ModifyServerlessCacheResponse(data.ModifyServerlessCacheResult, context);
+    contents = de_TestMigrationResponse(data.TestMigrationResult, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ModifyServerlessCacheCommandError = async (output, context) => {
+const de_CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
     };
     const errorCode = loadQueryErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "InvalidCredentialsException":
-        case "com.amazonaws.elasticache#InvalidCredentialsException":
-            throw await de_InvalidCredentialsExceptionRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+        case "CacheClusterNotFound":
+        case "com.amazonaws.elasticache#CacheClusterNotFoundFault":
+            throw await de_CacheClusterNotFoundFaultRes(parsedOutput, context);
+        case "CacheParameterGroupNotFound":
+        case "com.amazonaws.elasticache#CacheParameterGroupNotFoundFault":
+            throw await de_CacheParameterGroupNotFoundFaultRes(parsedOutput, context);
+        case "CacheSecurityGroupNotFound":
+        case "com.amazonaws.elasticache#CacheSecurityGroupNotFoundFault":
+            throw await de_CacheSecurityGroupNotFoundFaultRes(parsedOutput, context);
+        case "CacheSubnetGroupNotFoundFault":
+        case "com.amazonaws.elasticache#CacheSubnetGroupNotFoundFault":
+            throw await de_CacheSubnetGroupNotFoundFaultRes(parsedOutput, context);
+        case "InvalidARN":
+        case "com.amazonaws.elasticache#InvalidARNFault":
+            throw await de_InvalidARNFaultRes(parsedOutput, context);
+        case "InvalidReplicationGroupState":
+        case "com.amazonaws.elasticache#InvalidReplicationGroupStateFault":
+            throw await de_InvalidReplicationGroupStateFaultRes(parsedOutput, context);
+        case "InvalidServerlessCacheSnapshotStateFault":
+        case "com.amazonaws.elasticache#InvalidServerlessCacheSnapshotStateFault":
+            throw await de_InvalidServerlessCacheSnapshotStateFaultRes(parsedOutput, context);
         case "InvalidServerlessCacheStateFault":
         case "com.amazonaws.elasticache#InvalidServerlessCacheStateFault":
             throw await de_InvalidServerlessCacheStateFaultRes(parsedOutput, context);
-        case "InvalidUserGroupState":
-        case "com.amazonaws.elasticache#InvalidUserGroupStateFault":
-            throw await de_InvalidUserGroupStateFaultRes(parsedOutput, context);
+        case "ReplicationGroupNotFoundFault":
+        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
+            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
+        case "ReservedCacheNodeNotFound":
+        case "com.amazonaws.elasticache#ReservedCacheNodeNotFoundFault":
+            throw await de_ReservedCacheNodeNotFoundFaultRes(parsedOutput, context);
         case "ServerlessCacheNotFoundFault":
         case "com.amazonaws.elasticache#ServerlessCacheNotFoundFault":
             throw await de_ServerlessCacheNotFoundFaultRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+        case "ServerlessCacheSnapshotNotFoundFault":
+        case "com.amazonaws.elasticache#ServerlessCacheSnapshotNotFoundFault":
+            throw await de_ServerlessCacheSnapshotNotFoundFaultRes(parsedOutput, context);
+        case "SnapshotNotFoundFault":
+        case "com.amazonaws.elasticache#SnapshotNotFoundFault":
+            throw await de_SnapshotNotFoundFaultRes(parsedOutput, context);
+        case "TagQuotaPerResourceExceeded":
+        case "com.amazonaws.elasticache#TagQuotaPerResourceExceeded":
+            throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
         case "UserGroupNotFound":
         case "com.amazonaws.elasticache#UserGroupNotFoundFault":
             throw await de_UserGroupNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_ModifyUserCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_ModifyUserCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_User(data.ModifyUserResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ModifyUserCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidUserState":
-        case "com.amazonaws.elasticache#InvalidUserStateFault":
-            throw await de_InvalidUserStateFaultRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
         case "UserNotFound":
         case "com.amazonaws.elasticache#UserNotFoundFault":
             throw await de_UserNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_ModifyUserGroupCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_ModifyUserGroupCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_UserGroup(data.ModifyUserGroupResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ModifyUserGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "DefaultUserRequired":
-        case "com.amazonaws.elasticache#DefaultUserRequired":
-            throw await de_DefaultUserRequiredRes(parsedOutput, context);
-        case "DuplicateUserName":
-        case "com.amazonaws.elasticache#DuplicateUserNameFault":
-            throw await de_DuplicateUserNameFaultRes(parsedOutput, context);
+        case "AuthorizationAlreadyExists":
+        case "com.amazonaws.elasticache#AuthorizationAlreadyExistsFault":
+            throw await de_AuthorizationAlreadyExistsFaultRes(parsedOutput, context);
+        case "InvalidCacheSecurityGroupState":
+        case "com.amazonaws.elasticache#InvalidCacheSecurityGroupStateFault":
+            throw await de_InvalidCacheSecurityGroupStateFaultRes(parsedOutput, context);
         case "InvalidParameterCombination":
         case "com.amazonaws.elasticache#InvalidParameterCombinationException":
             throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
         case "InvalidParameterValue":
         case "com.amazonaws.elasticache#InvalidParameterValueException":
             throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidUserGroupState":
-        case "com.amazonaws.elasticache#InvalidUserGroupStateFault":
-            throw await de_InvalidUserGroupStateFaultRes(parsedOutput, context);
-        case "ServiceLinkedRoleNotFoundFault":
-        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
-            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
-        case "UserGroupNotFound":
-        case "com.amazonaws.elasticache#UserGroupNotFoundFault":
-            throw await de_UserGroupNotFoundFaultRes(parsedOutput, context);
-        case "UserNotFound":
-        case "com.amazonaws.elasticache#UserNotFoundFault":
-            throw await de_UserNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_PurchaseReservedCacheNodesOfferingCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_PurchaseReservedCacheNodesOfferingCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_PurchaseReservedCacheNodesOfferingResult(data.PurchaseReservedCacheNodesOfferingResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PurchaseReservedCacheNodesOfferingCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "ReservedCacheNodeAlreadyExists":
-        case "com.amazonaws.elasticache#ReservedCacheNodeAlreadyExistsFault":
-            throw await de_ReservedCacheNodeAlreadyExistsFaultRes(parsedOutput, context);
-        case "ReservedCacheNodeQuotaExceeded":
-        case "com.amazonaws.elasticache#ReservedCacheNodeQuotaExceededFault":
-            throw await de_ReservedCacheNodeQuotaExceededFaultRes(parsedOutput, context);
-        case "ReservedCacheNodesOfferingNotFound":
-        case "com.amazonaws.elasticache#ReservedCacheNodesOfferingNotFoundFault":
-            throw await de_ReservedCacheNodesOfferingNotFoundFaultRes(parsedOutput, context);
-        case "TagQuotaPerResourceExceeded":
-        case "com.amazonaws.elasticache#TagQuotaPerResourceExceeded":
-            throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_RebalanceSlotsInGlobalReplicationGroupCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_RebalanceSlotsInGlobalReplicationGroupCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_RebalanceSlotsInGlobalReplicationGroupResult(data.RebalanceSlotsInGlobalReplicationGroupResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_RebalanceSlotsInGlobalReplicationGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "GlobalReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#GlobalReplicationGroupNotFoundFault":
-            throw await de_GlobalReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidGlobalReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidGlobalReplicationGroupStateFault":
-            throw await de_InvalidGlobalReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_RebootCacheClusterCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_RebootCacheClusterCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_RebootCacheClusterResult(data.RebootCacheClusterResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_RebootCacheClusterCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheClusterNotFound":
-        case "com.amazonaws.elasticache#CacheClusterNotFoundFault":
-            throw await de_CacheClusterNotFoundFaultRes(parsedOutput, context);
-        case "InvalidCacheClusterState":
-        case "com.amazonaws.elasticache#InvalidCacheClusterStateFault":
-            throw await de_InvalidCacheClusterStateFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_RemoveTagsFromResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_RemoveTagsFromResourceCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_TagListMessage(data.RemoveTagsFromResourceResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_RemoveTagsFromResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheClusterNotFound":
-        case "com.amazonaws.elasticache#CacheClusterNotFoundFault":
-            throw await de_CacheClusterNotFoundFaultRes(parsedOutput, context);
-        case "CacheParameterGroupNotFound":
-        case "com.amazonaws.elasticache#CacheParameterGroupNotFoundFault":
-            throw await de_CacheParameterGroupNotFoundFaultRes(parsedOutput, context);
-        case "CacheSecurityGroupNotFound":
-        case "com.amazonaws.elasticache#CacheSecurityGroupNotFoundFault":
-            throw await de_CacheSecurityGroupNotFoundFaultRes(parsedOutput, context);
-        case "CacheSubnetGroupNotFoundFault":
-        case "com.amazonaws.elasticache#CacheSubnetGroupNotFoundFault":
-            throw await de_CacheSubnetGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidARN":
-        case "com.amazonaws.elasticache#InvalidARNFault":
-            throw await de_InvalidARNFaultRes(parsedOutput, context);
-        case "InvalidReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidReplicationGroupStateFault":
-            throw await de_InvalidReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidServerlessCacheSnapshotStateFault":
-        case "com.amazonaws.elasticache#InvalidServerlessCacheSnapshotStateFault":
-            throw await de_InvalidServerlessCacheSnapshotStateFaultRes(parsedOutput, context);
-        case "InvalidServerlessCacheStateFault":
-        case "com.amazonaws.elasticache#InvalidServerlessCacheStateFault":
-            throw await de_InvalidServerlessCacheStateFaultRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        case "ReservedCacheNodeNotFound":
-        case "com.amazonaws.elasticache#ReservedCacheNodeNotFoundFault":
-            throw await de_ReservedCacheNodeNotFoundFaultRes(parsedOutput, context);
-        case "ServerlessCacheNotFoundFault":
-        case "com.amazonaws.elasticache#ServerlessCacheNotFoundFault":
-            throw await de_ServerlessCacheNotFoundFaultRes(parsedOutput, context);
-        case "ServerlessCacheSnapshotNotFoundFault":
-        case "com.amazonaws.elasticache#ServerlessCacheSnapshotNotFoundFault":
-            throw await de_ServerlessCacheSnapshotNotFoundFaultRes(parsedOutput, context);
-        case "SnapshotNotFoundFault":
-        case "com.amazonaws.elasticache#SnapshotNotFoundFault":
-            throw await de_SnapshotNotFoundFaultRes(parsedOutput, context);
-        case "TagNotFound":
-        case "com.amazonaws.elasticache#TagNotFoundFault":
-            throw await de_TagNotFoundFaultRes(parsedOutput, context);
-        case "UserGroupNotFound":
-        case "com.amazonaws.elasticache#UserGroupNotFoundFault":
-            throw await de_UserGroupNotFoundFaultRes(parsedOutput, context);
-        case "UserNotFound":
-        case "com.amazonaws.elasticache#UserNotFoundFault":
-            throw await de_UserNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_ResetCacheParameterGroupCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_ResetCacheParameterGroupCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_CacheParameterGroupNameMessage(data.ResetCacheParameterGroupResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ResetCacheParameterGroupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CacheParameterGroupNotFound":
-        case "com.amazonaws.elasticache#CacheParameterGroupNotFoundFault":
-            throw await de_CacheParameterGroupNotFoundFaultRes(parsedOutput, context);
+        case "ServiceUpdateNotFoundFault":
+        case "com.amazonaws.elasticache#ServiceUpdateNotFoundFault":
+            throw await de_ServiceUpdateNotFoundFaultRes(parsedOutput, context);
+        case "ReplicationGroupNotUnderMigrationFault":
+        case "com.amazonaws.elasticache#ReplicationGroupNotUnderMigrationFault":
+            throw await de_ReplicationGroupNotUnderMigrationFaultRes(parsedOutput, context);
+        case "ServerlessCacheSnapshotAlreadyExistsFault":
+        case "com.amazonaws.elasticache#ServerlessCacheSnapshotAlreadyExistsFault":
+            throw await de_ServerlessCacheSnapshotAlreadyExistsFaultRes(parsedOutput, context);
+        case "ServerlessCacheSnapshotQuotaExceededFault":
+        case "com.amazonaws.elasticache#ServerlessCacheSnapshotQuotaExceededFault":
+            throw await de_ServerlessCacheSnapshotQuotaExceededFaultRes(parsedOutput, context);
+        case "ServiceLinkedRoleNotFoundFault":
+        case "com.amazonaws.elasticache#ServiceLinkedRoleNotFoundFault":
+            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+        case "InvalidSnapshotState":
+        case "com.amazonaws.elasticache#InvalidSnapshotStateFault":
+            throw await de_InvalidSnapshotStateFaultRes(parsedOutput, context);
+        case "SnapshotAlreadyExistsFault":
+        case "com.amazonaws.elasticache#SnapshotAlreadyExistsFault":
+            throw await de_SnapshotAlreadyExistsFaultRes(parsedOutput, context);
+        case "SnapshotQuotaExceededFault":
+        case "com.amazonaws.elasticache#SnapshotQuotaExceededFault":
+            throw await de_SnapshotQuotaExceededFaultRes(parsedOutput, context);
+        case "CacheClusterAlreadyExists":
+        case "com.amazonaws.elasticache#CacheClusterAlreadyExistsFault":
+            throw await de_CacheClusterAlreadyExistsFaultRes(parsedOutput, context);
+        case "ClusterQuotaForCustomerExceeded":
+        case "com.amazonaws.elasticache#ClusterQuotaForCustomerExceededFault":
+            throw await de_ClusterQuotaForCustomerExceededFaultRes(parsedOutput, context);
+        case "InsufficientCacheClusterCapacity":
+        case "com.amazonaws.elasticache#InsufficientCacheClusterCapacityFault":
+            throw await de_InsufficientCacheClusterCapacityFaultRes(parsedOutput, context);
+        case "InvalidVPCNetworkStateFault":
+        case "com.amazonaws.elasticache#InvalidVPCNetworkStateFault":
+            throw await de_InvalidVPCNetworkStateFaultRes(parsedOutput, context);
+        case "NodeQuotaForClusterExceeded":
+        case "com.amazonaws.elasticache#NodeQuotaForClusterExceededFault":
+            throw await de_NodeQuotaForClusterExceededFaultRes(parsedOutput, context);
+        case "NodeQuotaForCustomerExceeded":
+        case "com.amazonaws.elasticache#NodeQuotaForCustomerExceededFault":
+            throw await de_NodeQuotaForCustomerExceededFaultRes(parsedOutput, context);
+        case "CacheParameterGroupAlreadyExists":
+        case "com.amazonaws.elasticache#CacheParameterGroupAlreadyExistsFault":
+            throw await de_CacheParameterGroupAlreadyExistsFaultRes(parsedOutput, context);
+        case "CacheParameterGroupQuotaExceeded":
+        case "com.amazonaws.elasticache#CacheParameterGroupQuotaExceededFault":
+            throw await de_CacheParameterGroupQuotaExceededFaultRes(parsedOutput, context);
         case "InvalidCacheParameterGroupState":
         case "com.amazonaws.elasticache#InvalidCacheParameterGroupStateFault":
             throw await de_InvalidCacheParameterGroupStateFaultRes(parsedOutput, context);
+        case "CacheSecurityGroupAlreadyExists":
+        case "com.amazonaws.elasticache#CacheSecurityGroupAlreadyExistsFault":
+            throw await de_CacheSecurityGroupAlreadyExistsFaultRes(parsedOutput, context);
+        case "QuotaExceeded.CacheSecurityGroup":
+        case "com.amazonaws.elasticache#CacheSecurityGroupQuotaExceededFault":
+            throw await de_CacheSecurityGroupQuotaExceededFaultRes(parsedOutput, context);
+        case "CacheSubnetGroupAlreadyExists":
+        case "com.amazonaws.elasticache#CacheSubnetGroupAlreadyExistsFault":
+            throw await de_CacheSubnetGroupAlreadyExistsFaultRes(parsedOutput, context);
+        case "CacheSubnetGroupQuotaExceeded":
+        case "com.amazonaws.elasticache#CacheSubnetGroupQuotaExceededFault":
+            throw await de_CacheSubnetGroupQuotaExceededFaultRes(parsedOutput, context);
+        case "CacheSubnetQuotaExceededFault":
+        case "com.amazonaws.elasticache#CacheSubnetQuotaExceededFault":
+            throw await de_CacheSubnetQuotaExceededFaultRes(parsedOutput, context);
+        case "InvalidSubnet":
+        case "com.amazonaws.elasticache#InvalidSubnet":
+            throw await de_InvalidSubnetRes(parsedOutput, context);
+        case "SubnetNotAllowedFault":
+        case "com.amazonaws.elasticache#SubnetNotAllowedFault":
+            throw await de_SubnetNotAllowedFaultRes(parsedOutput, context);
+        case "GlobalReplicationGroupAlreadyExistsFault":
+        case "com.amazonaws.elasticache#GlobalReplicationGroupAlreadyExistsFault":
+            throw await de_GlobalReplicationGroupAlreadyExistsFaultRes(parsedOutput, context);
+        case "GlobalReplicationGroupNotFoundFault":
+        case "com.amazonaws.elasticache#GlobalReplicationGroupNotFoundFault":
+            throw await de_GlobalReplicationGroupNotFoundFaultRes(parsedOutput, context);
+        case "InvalidCacheClusterState":
+        case "com.amazonaws.elasticache#InvalidCacheClusterStateFault":
+            throw await de_InvalidCacheClusterStateFaultRes(parsedOutput, context);
         case "InvalidGlobalReplicationGroupState":
         case "com.amazonaws.elasticache#InvalidGlobalReplicationGroupStateFault":
             throw await de_InvalidGlobalReplicationGroupStateFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_RevokeCacheSecurityGroupIngressCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_RevokeCacheSecurityGroupIngressCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_RevokeCacheSecurityGroupIngressResult(data.RevokeCacheSecurityGroupIngressResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_RevokeCacheSecurityGroupIngressCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
+        case "InvalidUserGroupState":
+        case "com.amazonaws.elasticache#InvalidUserGroupStateFault":
+            throw await de_InvalidUserGroupStateFaultRes(parsedOutput, context);
+        case "NodeGroupsPerReplicationGroupQuotaExceeded":
+        case "com.amazonaws.elasticache#NodeGroupsPerReplicationGroupQuotaExceededFault":
+            throw await de_NodeGroupsPerReplicationGroupQuotaExceededFaultRes(parsedOutput, context);
+        case "ReplicationGroupAlreadyExists":
+        case "com.amazonaws.elasticache#ReplicationGroupAlreadyExistsFault":
+            throw await de_ReplicationGroupAlreadyExistsFaultRes(parsedOutput, context);
+        case "InvalidCredentialsException":
+        case "com.amazonaws.elasticache#InvalidCredentialsException":
+            throw await de_InvalidCredentialsExceptionRes(parsedOutput, context);
+        case "ServerlessCacheAlreadyExistsFault":
+        case "com.amazonaws.elasticache#ServerlessCacheAlreadyExistsFault":
+            throw await de_ServerlessCacheAlreadyExistsFaultRes(parsedOutput, context);
+        case "ServerlessCacheQuotaForCustomerExceededFault":
+        case "com.amazonaws.elasticache#ServerlessCacheQuotaForCustomerExceededFault":
+            throw await de_ServerlessCacheQuotaForCustomerExceededFaultRes(parsedOutput, context);
+        case "SnapshotFeatureNotSupportedFault":
+        case "com.amazonaws.elasticache#SnapshotFeatureNotSupportedFault":
+            throw await de_SnapshotFeatureNotSupportedFaultRes(parsedOutput, context);
+        case "DuplicateUserName":
+        case "com.amazonaws.elasticache#DuplicateUserNameFault":
+            throw await de_DuplicateUserNameFaultRes(parsedOutput, context);
+        case "UserAlreadyExists":
+        case "com.amazonaws.elasticache#UserAlreadyExistsFault":
+            throw await de_UserAlreadyExistsFaultRes(parsedOutput, context);
+        case "UserQuotaExceeded":
+        case "com.amazonaws.elasticache#UserQuotaExceededFault":
+            throw await de_UserQuotaExceededFaultRes(parsedOutput, context);
+        case "DefaultUserRequired":
+        case "com.amazonaws.elasticache#DefaultUserRequired":
+            throw await de_DefaultUserRequiredRes(parsedOutput, context);
+        case "UserGroupAlreadyExists":
+        case "com.amazonaws.elasticache#UserGroupAlreadyExistsFault":
+            throw await de_UserGroupAlreadyExistsFaultRes(parsedOutput, context);
+        case "UserGroupQuotaExceeded":
+        case "com.amazonaws.elasticache#UserGroupQuotaExceededFault":
+            throw await de_UserGroupQuotaExceededFaultRes(parsedOutput, context);
+        case "NoOperationFault":
+        case "com.amazonaws.elasticache#NoOperationFault":
+            throw await de_NoOperationFaultRes(parsedOutput, context);
+        case "CacheSubnetGroupInUse":
+        case "com.amazonaws.elasticache#CacheSubnetGroupInUse":
+            throw await de_CacheSubnetGroupInUseRes(parsedOutput, context);
+        case "DefaultUserAssociatedToUserGroup":
+        case "com.amazonaws.elasticache#DefaultUserAssociatedToUserGroupFault":
+            throw await de_DefaultUserAssociatedToUserGroupFaultRes(parsedOutput, context);
+        case "InvalidUserState":
+        case "com.amazonaws.elasticache#InvalidUserStateFault":
+            throw await de_InvalidUserStateFaultRes(parsedOutput, context);
+        case "ReservedCacheNodesOfferingNotFound":
+        case "com.amazonaws.elasticache#ReservedCacheNodesOfferingNotFoundFault":
+            throw await de_ReservedCacheNodesOfferingNotFoundFaultRes(parsedOutput, context);
+        case "InvalidKMSKeyFault":
+        case "com.amazonaws.elasticache#InvalidKMSKeyFault":
+            throw await de_InvalidKMSKeyFaultRes(parsedOutput, context);
+        case "SubnetInUse":
+        case "com.amazonaws.elasticache#SubnetInUse":
+            throw await de_SubnetInUseRes(parsedOutput, context);
+        case "ReservedCacheNodeAlreadyExists":
+        case "com.amazonaws.elasticache#ReservedCacheNodeAlreadyExistsFault":
+            throw await de_ReservedCacheNodeAlreadyExistsFaultRes(parsedOutput, context);
+        case "ReservedCacheNodeQuotaExceeded":
+        case "com.amazonaws.elasticache#ReservedCacheNodeQuotaExceededFault":
+            throw await de_ReservedCacheNodeQuotaExceededFaultRes(parsedOutput, context);
+        case "TagNotFound":
+        case "com.amazonaws.elasticache#TagNotFoundFault":
+            throw await de_TagNotFoundFaultRes(parsedOutput, context);
         case "AuthorizationNotFound":
         case "com.amazonaws.elasticache#AuthorizationNotFoundFault":
             throw await de_AuthorizationNotFoundFaultRes(parsedOutput, context);
-        case "CacheSecurityGroupNotFound":
-        case "com.amazonaws.elasticache#CacheSecurityGroupNotFoundFault":
-            throw await de_CacheSecurityGroupNotFoundFaultRes(parsedOutput, context);
-        case "InvalidCacheSecurityGroupState":
-        case "com.amazonaws.elasticache#InvalidCacheSecurityGroupStateFault":
-            throw await de_InvalidCacheSecurityGroupStateFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_StartMigrationCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_StartMigrationCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_StartMigrationResponse(data.StartMigrationResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_StartMigrationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidReplicationGroupStateFault":
-            throw await de_InvalidReplicationGroupStateFaultRes(parsedOutput, context);
         case "ReplicationGroupAlreadyUnderMigrationFault":
         case "com.amazonaws.elasticache#ReplicationGroupAlreadyUnderMigrationFault":
             throw await de_ReplicationGroupAlreadyUnderMigrationFaultRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
-export const de_TestFailoverCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_TestFailoverCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_TestFailoverResult(data.TestFailoverResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_TestFailoverCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
         case "APICallRateForCustomerExceeded":
         case "com.amazonaws.elasticache#APICallRateForCustomerExceededFault":
             throw await de_APICallRateForCustomerExceededFaultRes(parsedOutput, context);
-        case "InvalidCacheClusterState":
-        case "com.amazonaws.elasticache#InvalidCacheClusterStateFault":
-            throw await de_InvalidCacheClusterStateFaultRes(parsedOutput, context);
-        case "InvalidKMSKeyFault":
-        case "com.amazonaws.elasticache#InvalidKMSKeyFault":
-            throw await de_InvalidKMSKeyFaultRes(parsedOutput, context);
-        case "InvalidParameterCombination":
-        case "com.amazonaws.elasticache#InvalidParameterCombinationException":
-            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidReplicationGroupStateFault":
-            throw await de_InvalidReplicationGroupStateFaultRes(parsedOutput, context);
         case "NodeGroupNotFoundFault":
         case "com.amazonaws.elasticache#NodeGroupNotFoundFault":
             throw await de_NodeGroupNotFoundFaultRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
         case "TestFailoverNotAvailableFault":
         case "com.amazonaws.elasticache#TestFailoverNotAvailableFault":
             throw await de_TestFailoverNotAvailableFaultRes(parsedOutput, context);
@@ -4169,47 +1964,6 @@ const de_TestFailoverCommandError = async (output, context) => {
             });
     }
 };
-export const de_TestMigrationCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_TestMigrationCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_TestMigrationResponse(data.TestMigrationResult, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_TestMigrationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterValue":
-        case "com.amazonaws.elasticache#InvalidParameterValueException":
-            throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
-        case "InvalidReplicationGroupState":
-        case "com.amazonaws.elasticache#InvalidReplicationGroupStateFault":
-            throw await de_InvalidReplicationGroupStateFaultRes(parsedOutput, context);
-        case "ReplicationGroupAlreadyUnderMigrationFault":
-        case "com.amazonaws.elasticache#ReplicationGroupAlreadyUnderMigrationFault":
-            throw await de_ReplicationGroupAlreadyUnderMigrationFaultRes(parsedOutput, context);
-        case "ReplicationGroupNotFoundFault":
-        case "com.amazonaws.elasticache#ReplicationGroupNotFoundFault":
-            throw await de_ReplicationGroupNotFoundFaultRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
-};
 const de_APICallRateForCustomerExceededFaultRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = de_APICallRateForCustomerExceededFault(body.Error, context);