@aws-sdk/client-redshift-serverless 3.303.0 → 3.309.0

package/dist-es/protocols/Aws_json1_1.js

@@ -2,380 +2,380 @@ import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, limitedParseDouble as __limitedParseDouble, parseEpochTimestamp as __parseEpochTimestamp, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { AccessDeniedException, ConflictException, InsufficientCapacityException, InternalServerException, InvalidPaginationException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, TooManyTagsException, ValidationException, } from "../models/models_0";
 import { RedshiftServerlessServiceException as __BaseException } from "../models/RedshiftServerlessServiceException";
-export const serializeAws_json1_1ConvertRecoveryPointToSnapshotCommand = async (input, context) => {
+export const se_ConvertRecoveryPointToSnapshotCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.ConvertRecoveryPointToSnapshot",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ConvertRecoveryPointToSnapshotRequest(input, context));
+    body = JSON.stringify(se_ConvertRecoveryPointToSnapshotRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreateEndpointAccessCommand = async (input, context) => {
+export const se_CreateEndpointAccessCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.CreateEndpointAccess",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateEndpointAccessRequest(input, context));
+    body = JSON.stringify(se_CreateEndpointAccessRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreateNamespaceCommand = async (input, context) => {
+export const se_CreateNamespaceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.CreateNamespace",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateNamespaceRequest(input, context));
+    body = JSON.stringify(se_CreateNamespaceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreateSnapshotCommand = async (input, context) => {
+export const se_CreateSnapshotCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.CreateSnapshot",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateSnapshotRequest(input, context));
+    body = JSON.stringify(se_CreateSnapshotRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreateUsageLimitCommand = async (input, context) => {
+export const se_CreateUsageLimitCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.CreateUsageLimit",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateUsageLimitRequest(input, context));
+    body = JSON.stringify(se_CreateUsageLimitRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreateWorkgroupCommand = async (input, context) => {
+export const se_CreateWorkgroupCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.CreateWorkgroup",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateWorkgroupRequest(input, context));
+    body = JSON.stringify(se_CreateWorkgroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteEndpointAccessCommand = async (input, context) => {
+export const se_DeleteEndpointAccessCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.DeleteEndpointAccess",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteEndpointAccessRequest(input, context));
+    body = JSON.stringify(se_DeleteEndpointAccessRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteNamespaceCommand = async (input, context) => {
+export const se_DeleteNamespaceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.DeleteNamespace",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteNamespaceRequest(input, context));
+    body = JSON.stringify(se_DeleteNamespaceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteResourcePolicyCommand = async (input, context) => {
+export const se_DeleteResourcePolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.DeleteResourcePolicy",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteResourcePolicyRequest(input, context));
+    body = JSON.stringify(se_DeleteResourcePolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteSnapshotCommand = async (input, context) => {
+export const se_DeleteSnapshotCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.DeleteSnapshot",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteSnapshotRequest(input, context));
+    body = JSON.stringify(se_DeleteSnapshotRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteUsageLimitCommand = async (input, context) => {
+export const se_DeleteUsageLimitCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.DeleteUsageLimit",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteUsageLimitRequest(input, context));
+    body = JSON.stringify(se_DeleteUsageLimitRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteWorkgroupCommand = async (input, context) => {
+export const se_DeleteWorkgroupCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.DeleteWorkgroup",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteWorkgroupRequest(input, context));
+    body = JSON.stringify(se_DeleteWorkgroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetCredentialsCommand = async (input, context) => {
+export const se_GetCredentialsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.GetCredentials",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetCredentialsRequest(input, context));
+    body = JSON.stringify(se_GetCredentialsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetEndpointAccessCommand = async (input, context) => {
+export const se_GetEndpointAccessCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.GetEndpointAccess",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetEndpointAccessRequest(input, context));
+    body = JSON.stringify(se_GetEndpointAccessRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetNamespaceCommand = async (input, context) => {
+export const se_GetNamespaceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.GetNamespace",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetNamespaceRequest(input, context));
+    body = JSON.stringify(se_GetNamespaceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetRecoveryPointCommand = async (input, context) => {
+export const se_GetRecoveryPointCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.GetRecoveryPoint",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetRecoveryPointRequest(input, context));
+    body = JSON.stringify(se_GetRecoveryPointRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetResourcePolicyCommand = async (input, context) => {
+export const se_GetResourcePolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.GetResourcePolicy",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetResourcePolicyRequest(input, context));
+    body = JSON.stringify(se_GetResourcePolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetSnapshotCommand = async (input, context) => {
+export const se_GetSnapshotCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.GetSnapshot",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetSnapshotRequest(input, context));
+    body = JSON.stringify(se_GetSnapshotRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetTableRestoreStatusCommand = async (input, context) => {
+export const se_GetTableRestoreStatusCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.GetTableRestoreStatus",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetTableRestoreStatusRequest(input, context));
+    body = JSON.stringify(se_GetTableRestoreStatusRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetUsageLimitCommand = async (input, context) => {
+export const se_GetUsageLimitCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.GetUsageLimit",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetUsageLimitRequest(input, context));
+    body = JSON.stringify(se_GetUsageLimitRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetWorkgroupCommand = async (input, context) => {
+export const se_GetWorkgroupCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.GetWorkgroup",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetWorkgroupRequest(input, context));
+    body = JSON.stringify(se_GetWorkgroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListEndpointAccessCommand = async (input, context) => {
+export const se_ListEndpointAccessCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.ListEndpointAccess",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListEndpointAccessRequest(input, context));
+    body = JSON.stringify(se_ListEndpointAccessRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListNamespacesCommand = async (input, context) => {
+export const se_ListNamespacesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.ListNamespaces",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListNamespacesRequest(input, context));
+    body = JSON.stringify(se_ListNamespacesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListRecoveryPointsCommand = async (input, context) => {
+export const se_ListRecoveryPointsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.ListRecoveryPoints",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListRecoveryPointsRequest(input, context));
+    body = JSON.stringify(se_ListRecoveryPointsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListSnapshotsCommand = async (input, context) => {
+export const se_ListSnapshotsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.ListSnapshots",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListSnapshotsRequest(input, context));
+    body = JSON.stringify(se_ListSnapshotsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListTableRestoreStatusCommand = async (input, context) => {
+export const se_ListTableRestoreStatusCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.ListTableRestoreStatus",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListTableRestoreStatusRequest(input, context));
+    body = JSON.stringify(se_ListTableRestoreStatusRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListTagsForResourceCommand = async (input, context) => {
+export const se_ListTagsForResourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.ListTagsForResource",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListTagsForResourceRequest(input, context));
+    body = JSON.stringify(se_ListTagsForResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListUsageLimitsCommand = async (input, context) => {
+export const se_ListUsageLimitsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.ListUsageLimits",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListUsageLimitsRequest(input, context));
+    body = JSON.stringify(se_ListUsageLimitsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListWorkgroupsCommand = async (input, context) => {
+export const se_ListWorkgroupsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.ListWorkgroups",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListWorkgroupsRequest(input, context));
+    body = JSON.stringify(se_ListWorkgroupsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1PutResourcePolicyCommand = async (input, context) => {
+export const se_PutResourcePolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.PutResourcePolicy",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1PutResourcePolicyRequest(input, context));
+    body = JSON.stringify(se_PutResourcePolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1RestoreFromRecoveryPointCommand = async (input, context) => {
+export const se_RestoreFromRecoveryPointCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.RestoreFromRecoveryPoint",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1RestoreFromRecoveryPointRequest(input, context));
+    body = JSON.stringify(se_RestoreFromRecoveryPointRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1RestoreFromSnapshotCommand = async (input, context) => {
+export const se_RestoreFromSnapshotCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.RestoreFromSnapshot",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1RestoreFromSnapshotRequest(input, context));
+    body = JSON.stringify(se_RestoreFromSnapshotRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1RestoreTableFromSnapshotCommand = async (input, context) => {
+export const se_RestoreTableFromSnapshotCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.RestoreTableFromSnapshot",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1RestoreTableFromSnapshotRequest(input, context));
+    body = JSON.stringify(se_RestoreTableFromSnapshotRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1TagResourceCommand = async (input, context) => {
+export const se_TagResourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.TagResource",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1TagResourceRequest(input, context));
+    body = JSON.stringify(se_TagResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UntagResourceCommand = async (input, context) => {
+export const se_UntagResourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.UntagResource",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UntagResourceRequest(input, context));
+    body = JSON.stringify(se_UntagResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UpdateEndpointAccessCommand = async (input, context) => {
+export const se_UpdateEndpointAccessCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.UpdateEndpointAccess",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UpdateEndpointAccessRequest(input, context));
+    body = JSON.stringify(se_UpdateEndpointAccessRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UpdateNamespaceCommand = async (input, context) => {
+export const se_UpdateNamespaceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.UpdateNamespace",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UpdateNamespaceRequest(input, context));
+    body = JSON.stringify(se_UpdateNamespaceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UpdateSnapshotCommand = async (input, context) => {
+export const se_UpdateSnapshotCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.UpdateSnapshot",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UpdateSnapshotRequest(input, context));
+    body = JSON.stringify(se_UpdateSnapshotRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UpdateUsageLimitCommand = async (input, context) => {
+export const se_UpdateUsageLimitCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.UpdateUsageLimit",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UpdateUsageLimitRequest(input, context));
+    body = JSON.stringify(se_UpdateUsageLimitRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UpdateWorkgroupCommand = async (input, context) => {
+export const se_UpdateWorkgroupCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "RedshiftServerless.UpdateWorkgroup",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UpdateWorkgroupRequest(input, context));
+    body = JSON.stringify(se_UpdateWorkgroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const deserializeAws_json1_1ConvertRecoveryPointToSnapshotCommand = async (output, context) => {
+export const de_ConvertRecoveryPointToSnapshotCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ConvertRecoveryPointToSnapshotCommandError(output, context);
+        return de_ConvertRecoveryPointToSnapshotCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ConvertRecoveryPointToSnapshotResponse(data, context);
+    contents = de_ConvertRecoveryPointToSnapshotResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ConvertRecoveryPointToSnapshotCommandError = async (output, context) => {
+const de_ConvertRecoveryPointToSnapshotCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -384,22 +384,22 @@ const deserializeAws_json1_1ConvertRecoveryPointToSnapshotCommandError = async (
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceQuotaExceededException":
         case "com.amazonaws.redshiftserverless#ServiceQuotaExceededException":
-            throw await deserializeAws_json1_1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.redshiftserverless#TooManyTagsException":
-            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -410,20 +410,20 @@ const deserializeAws_json1_1ConvertRecoveryPointToSnapshotCommandError = async (
             });
     }
 };
-export const deserializeAws_json1_1CreateEndpointAccessCommand = async (output, context) => {
+export const de_CreateEndpointAccessCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateEndpointAccessCommandError(output, context);
+        return de_CreateEndpointAccessCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CreateEndpointAccessResponse(data, context);
+    contents = de_CreateEndpointAccessResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateEndpointAccessCommandError = async (output, context) => {
+const de_CreateEndpointAccessCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -432,22 +432,22 @@ const deserializeAws_json1_1CreateEndpointAccessCommandError = async (output, co
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.redshiftserverless#AccessDeniedException":
-            throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceQuotaExceededException":
         case "com.amazonaws.redshiftserverless#ServiceQuotaExceededException":
-            throw await deserializeAws_json1_1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -458,20 +458,20 @@ const deserializeAws_json1_1CreateEndpointAccessCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_json1_1CreateNamespaceCommand = async (output, context) => {
+export const de_CreateNamespaceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateNamespaceCommandError(output, context);
+        return de_CreateNamespaceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CreateNamespaceResponse(data, context);
+    contents = de_CreateNamespaceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateNamespaceCommandError = async (output, context) => {
+const de_CreateNamespaceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -480,16 +480,16 @@ const deserializeAws_json1_1CreateNamespaceCommandError = async (output, context
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.redshiftserverless#TooManyTagsException":
-            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -500,20 +500,20 @@ const deserializeAws_json1_1CreateNamespaceCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_json1_1CreateSnapshotCommand = async (output, context) => {
+export const de_CreateSnapshotCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateSnapshotCommandError(output, context);
+        return de_CreateSnapshotCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CreateSnapshotResponse(data, context);
+    contents = de_CreateSnapshotResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateSnapshotCommandError = async (output, context) => {
+const de_CreateSnapshotCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -522,22 +522,22 @@ const deserializeAws_json1_1CreateSnapshotCommandError = async (output, context)
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceQuotaExceededException":
         case "com.amazonaws.redshiftserverless#ServiceQuotaExceededException":
-            throw await deserializeAws_json1_1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.redshiftserverless#TooManyTagsException":
-            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -548,20 +548,20 @@ const deserializeAws_json1_1CreateSnapshotCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1CreateUsageLimitCommand = async (output, context) => {
+export const de_CreateUsageLimitCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateUsageLimitCommandError(output, context);
+        return de_CreateUsageLimitCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CreateUsageLimitResponse(data, context);
+    contents = de_CreateUsageLimitResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateUsageLimitCommandError = async (output, context) => {
+const de_CreateUsageLimitCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -570,19 +570,19 @@ const deserializeAws_json1_1CreateUsageLimitCommandError = async (output, contex
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceQuotaExceededException":
         case "com.amazonaws.redshiftserverless#ServiceQuotaExceededException":
-            throw await deserializeAws_json1_1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -593,20 +593,20 @@ const deserializeAws_json1_1CreateUsageLimitCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1CreateWorkgroupCommand = async (output, context) => {
+export const de_CreateWorkgroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateWorkgroupCommandError(output, context);
+        return de_CreateWorkgroupCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CreateWorkgroupResponse(data, context);
+    contents = de_CreateWorkgroupResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateWorkgroupCommandError = async (output, context) => {
+const de_CreateWorkgroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -615,22 +615,22 @@ const deserializeAws_json1_1CreateWorkgroupCommandError = async (output, context
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InsufficientCapacityException":
         case "com.amazonaws.redshiftserverless#InsufficientCapacityException":
-            throw await deserializeAws_json1_1InsufficientCapacityExceptionResponse(parsedOutput, context);
+            throw await de_InsufficientCapacityExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.redshiftserverless#TooManyTagsException":
-            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -641,20 +641,20 @@ const deserializeAws_json1_1CreateWorkgroupCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_json1_1DeleteEndpointAccessCommand = async (output, context) => {
+export const de_DeleteEndpointAccessCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteEndpointAccessCommandError(output, context);
+        return de_DeleteEndpointAccessCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DeleteEndpointAccessResponse(data, context);
+    contents = de_DeleteEndpointAccessResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteEndpointAccessCommandError = async (output, context) => {
+const de_DeleteEndpointAccessCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -663,16 +663,16 @@ const deserializeAws_json1_1DeleteEndpointAccessCommandError = async (output, co
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -683,20 +683,20 @@ const deserializeAws_json1_1DeleteEndpointAccessCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_json1_1DeleteNamespaceCommand = async (output, context) => {
+export const de_DeleteNamespaceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteNamespaceCommandError(output, context);
+        return de_DeleteNamespaceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DeleteNamespaceResponse(data, context);
+    contents = de_DeleteNamespaceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteNamespaceCommandError = async (output, context) => {
+const de_DeleteNamespaceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -705,16 +705,16 @@ const deserializeAws_json1_1DeleteNamespaceCommandError = async (output, context
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -725,20 +725,20 @@ const deserializeAws_json1_1DeleteNamespaceCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_json1_1DeleteResourcePolicyCommand = async (output, context) => {
+export const de_DeleteResourcePolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteResourcePolicyCommandError(output, context);
+        return de_DeleteResourcePolicyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DeleteResourcePolicyResponse(data, context);
+    contents = de_DeleteResourcePolicyResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteResourcePolicyCommandError = async (output, context) => {
+const de_DeleteResourcePolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -747,13 +747,13 @@ const deserializeAws_json1_1DeleteResourcePolicyCommandError = async (output, co
     switch (errorCode) {
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -764,20 +764,20 @@ const deserializeAws_json1_1DeleteResourcePolicyCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_json1_1DeleteSnapshotCommand = async (output, context) => {
+export const de_DeleteSnapshotCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteSnapshotCommandError(output, context);
+        return de_DeleteSnapshotCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DeleteSnapshotResponse(data, context);
+    contents = de_DeleteSnapshotResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteSnapshotCommandError = async (output, context) => {
+const de_DeleteSnapshotCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -786,16 +786,16 @@ const deserializeAws_json1_1DeleteSnapshotCommandError = async (output, context)
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -806,20 +806,20 @@ const deserializeAws_json1_1DeleteSnapshotCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1DeleteUsageLimitCommand = async (output, context) => {
+export const de_DeleteUsageLimitCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteUsageLimitCommandError(output, context);
+        return de_DeleteUsageLimitCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DeleteUsageLimitResponse(data, context);
+    contents = de_DeleteUsageLimitResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteUsageLimitCommandError = async (output, context) => {
+const de_DeleteUsageLimitCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -828,16 +828,16 @@ const deserializeAws_json1_1DeleteUsageLimitCommandError = async (output, contex
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -848,20 +848,20 @@ const deserializeAws_json1_1DeleteUsageLimitCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1DeleteWorkgroupCommand = async (output, context) => {
+export const de_DeleteWorkgroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteWorkgroupCommandError(output, context);
+        return de_DeleteWorkgroupCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DeleteWorkgroupResponse(data, context);
+    contents = de_DeleteWorkgroupResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteWorkgroupCommandError = async (output, context) => {
+const de_DeleteWorkgroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -870,16 +870,16 @@ const deserializeAws_json1_1DeleteWorkgroupCommandError = async (output, context
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -890,20 +890,20 @@ const deserializeAws_json1_1DeleteWorkgroupCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_json1_1GetCredentialsCommand = async (output, context) => {
+export const de_GetCredentialsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetCredentialsCommandError(output, context);
+        return de_GetCredentialsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetCredentialsResponse(data, context);
+    contents = de_GetCredentialsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetCredentialsCommandError = async (output, context) => {
+const de_GetCredentialsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -912,13 +912,13 @@ const deserializeAws_json1_1GetCredentialsCommandError = async (output, context)
     switch (errorCode) {
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -929,20 +929,20 @@ const deserializeAws_json1_1GetCredentialsCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1GetEndpointAccessCommand = async (output, context) => {
+export const de_GetEndpointAccessCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetEndpointAccessCommandError(output, context);
+        return de_GetEndpointAccessCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetEndpointAccessResponse(data, context);
+    contents = de_GetEndpointAccessResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetEndpointAccessCommandError = async (output, context) => {
+const de_GetEndpointAccessCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -951,16 +951,16 @@ const deserializeAws_json1_1GetEndpointAccessCommandError = async (output, conte
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -971,20 +971,20 @@ const deserializeAws_json1_1GetEndpointAccessCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_json1_1GetNamespaceCommand = async (output, context) => {
+export const de_GetNamespaceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetNamespaceCommandError(output, context);
+        return de_GetNamespaceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetNamespaceResponse(data, context);
+    contents = de_GetNamespaceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetNamespaceCommandError = async (output, context) => {
+const de_GetNamespaceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -993,13 +993,13 @@ const deserializeAws_json1_1GetNamespaceCommandError = async (output, context) =
     switch (errorCode) {
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1010,20 +1010,20 @@ const deserializeAws_json1_1GetNamespaceCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_json1_1GetRecoveryPointCommand = async (output, context) => {
+export const de_GetRecoveryPointCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetRecoveryPointCommandError(output, context);
+        return de_GetRecoveryPointCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetRecoveryPointResponse(data, context);
+    contents = de_GetRecoveryPointResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetRecoveryPointCommandError = async (output, context) => {
+const de_GetRecoveryPointCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1032,16 +1032,16 @@ const deserializeAws_json1_1GetRecoveryPointCommandError = async (output, contex
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1052,20 +1052,20 @@ const deserializeAws_json1_1GetRecoveryPointCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1GetResourcePolicyCommand = async (output, context) => {
+export const de_GetResourcePolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetResourcePolicyCommandError(output, context);
+        return de_GetResourcePolicyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetResourcePolicyResponse(data, context);
+    contents = de_GetResourcePolicyResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetResourcePolicyCommandError = async (output, context) => {
+const de_GetResourcePolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1074,13 +1074,13 @@ const deserializeAws_json1_1GetResourcePolicyCommandError = async (output, conte
     switch (errorCode) {
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1091,20 +1091,20 @@ const deserializeAws_json1_1GetResourcePolicyCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_json1_1GetSnapshotCommand = async (output, context) => {
+export const de_GetSnapshotCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetSnapshotCommandError(output, context);
+        return de_GetSnapshotCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetSnapshotResponse(data, context);
+    contents = de_GetSnapshotResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetSnapshotCommandError = async (output, context) => {
+const de_GetSnapshotCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1113,13 +1113,13 @@ const deserializeAws_json1_1GetSnapshotCommandError = async (output, context) =>
     switch (errorCode) {
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1130,20 +1130,20 @@ const deserializeAws_json1_1GetSnapshotCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_json1_1GetTableRestoreStatusCommand = async (output, context) => {
+export const de_GetTableRestoreStatusCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetTableRestoreStatusCommandError(output, context);
+        return de_GetTableRestoreStatusCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetTableRestoreStatusResponse(data, context);
+    contents = de_GetTableRestoreStatusResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetTableRestoreStatusCommandError = async (output, context) => {
+const de_GetTableRestoreStatusCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1152,10 +1152,10 @@ const deserializeAws_json1_1GetTableRestoreStatusCommandError = async (output, c
     switch (errorCode) {
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1166,20 +1166,20 @@ const deserializeAws_json1_1GetTableRestoreStatusCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1GetUsageLimitCommand = async (output, context) => {
+export const de_GetUsageLimitCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetUsageLimitCommandError(output, context);
+        return de_GetUsageLimitCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetUsageLimitResponse(data, context);
+    contents = de_GetUsageLimitResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetUsageLimitCommandError = async (output, context) => {
+const de_GetUsageLimitCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1188,16 +1188,16 @@ const deserializeAws_json1_1GetUsageLimitCommandError = async (output, context)
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1208,20 +1208,20 @@ const deserializeAws_json1_1GetUsageLimitCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1GetWorkgroupCommand = async (output, context) => {
+export const de_GetWorkgroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetWorkgroupCommandError(output, context);
+        return de_GetWorkgroupCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetWorkgroupResponse(data, context);
+    contents = de_GetWorkgroupResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetWorkgroupCommandError = async (output, context) => {
+const de_GetWorkgroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1230,13 +1230,13 @@ const deserializeAws_json1_1GetWorkgroupCommandError = async (output, context) =
     switch (errorCode) {
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1247,20 +1247,20 @@ const deserializeAws_json1_1GetWorkgroupCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_json1_1ListEndpointAccessCommand = async (output, context) => {
+export const de_ListEndpointAccessCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListEndpointAccessCommandError(output, context);
+        return de_ListEndpointAccessCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListEndpointAccessResponse(data, context);
+    contents = de_ListEndpointAccessResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListEndpointAccessCommandError = async (output, context) => {
+const de_ListEndpointAccessCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1269,16 +1269,16 @@ const deserializeAws_json1_1ListEndpointAccessCommandError = async (output, cont
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1289,20 +1289,20 @@ const deserializeAws_json1_1ListEndpointAccessCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_json1_1ListNamespacesCommand = async (output, context) => {
+export const de_ListNamespacesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListNamespacesCommandError(output, context);
+        return de_ListNamespacesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListNamespacesResponse(data, context);
+    contents = de_ListNamespacesResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListNamespacesCommandError = async (output, context) => {
+const de_ListNamespacesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1311,10 +1311,10 @@ const deserializeAws_json1_1ListNamespacesCommandError = async (output, context)
     switch (errorCode) {
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1325,20 +1325,20 @@ const deserializeAws_json1_1ListNamespacesCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1ListRecoveryPointsCommand = async (output, context) => {
+export const de_ListRecoveryPointsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListRecoveryPointsCommandError(output, context);
+        return de_ListRecoveryPointsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListRecoveryPointsResponse(data, context);
+    contents = de_ListRecoveryPointsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListRecoveryPointsCommandError = async (output, context) => {
+const de_ListRecoveryPointsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1347,10 +1347,10 @@ const deserializeAws_json1_1ListRecoveryPointsCommandError = async (output, cont
     switch (errorCode) {
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1361,20 +1361,20 @@ const deserializeAws_json1_1ListRecoveryPointsCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_json1_1ListSnapshotsCommand = async (output, context) => {
+export const de_ListSnapshotsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListSnapshotsCommandError(output, context);
+        return de_ListSnapshotsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListSnapshotsResponse(data, context);
+    contents = de_ListSnapshotsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListSnapshotsCommandError = async (output, context) => {
+const de_ListSnapshotsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1383,13 +1383,13 @@ const deserializeAws_json1_1ListSnapshotsCommandError = async (output, context)
     switch (errorCode) {
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1400,20 +1400,20 @@ const deserializeAws_json1_1ListSnapshotsCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1ListTableRestoreStatusCommand = async (output, context) => {
+export const de_ListTableRestoreStatusCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListTableRestoreStatusCommandError(output, context);
+        return de_ListTableRestoreStatusCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListTableRestoreStatusResponse(data, context);
+    contents = de_ListTableRestoreStatusResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListTableRestoreStatusCommandError = async (output, context) => {
+const de_ListTableRestoreStatusCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1422,13 +1422,13 @@ const deserializeAws_json1_1ListTableRestoreStatusCommandError = async (output,
     switch (errorCode) {
         case "InvalidPaginationException":
         case "com.amazonaws.redshiftserverless#InvalidPaginationException":
-            throw await deserializeAws_json1_1InvalidPaginationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidPaginationExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1439,20 +1439,20 @@ const deserializeAws_json1_1ListTableRestoreStatusCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1ListTagsForResourceCommand = async (output, context) => {
+export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListTagsForResourceCommandError(output, context);
+        return de_ListTagsForResourceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListTagsForResourceResponse(data, context);
+    contents = de_ListTagsForResourceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, context) => {
+const de_ListTagsForResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1461,16 +1461,16 @@ const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, con
     switch (errorCode) {
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.redshiftserverless#ThrottlingException":
-            throw await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1481,20 +1481,20 @@ const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1ListUsageLimitsCommand = async (output, context) => {
+export const de_ListUsageLimitsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListUsageLimitsCommandError(output, context);
+        return de_ListUsageLimitsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListUsageLimitsResponse(data, context);
+    contents = de_ListUsageLimitsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListUsageLimitsCommandError = async (output, context) => {
+const de_ListUsageLimitsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1503,19 +1503,19 @@ const deserializeAws_json1_1ListUsageLimitsCommandError = async (output, context
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "InvalidPaginationException":
         case "com.amazonaws.redshiftserverless#InvalidPaginationException":
-            throw await deserializeAws_json1_1InvalidPaginationExceptionResponse(parsedOutput, context);
+            throw await de_InvalidPaginationExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1526,20 +1526,20 @@ const deserializeAws_json1_1ListUsageLimitsCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_json1_1ListWorkgroupsCommand = async (output, context) => {
+export const de_ListWorkgroupsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListWorkgroupsCommandError(output, context);
+        return de_ListWorkgroupsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListWorkgroupsResponse(data, context);
+    contents = de_ListWorkgroupsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListWorkgroupsCommandError = async (output, context) => {
+const de_ListWorkgroupsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1548,10 +1548,10 @@ const deserializeAws_json1_1ListWorkgroupsCommandError = async (output, context)
     switch (errorCode) {
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1562,20 +1562,20 @@ const deserializeAws_json1_1ListWorkgroupsCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1PutResourcePolicyCommand = async (output, context) => {
+export const de_PutResourcePolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1PutResourcePolicyCommandError(output, context);
+        return de_PutResourcePolicyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1PutResourcePolicyResponse(data, context);
+    contents = de_PutResourcePolicyResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1PutResourcePolicyCommandError = async (output, context) => {
+const de_PutResourcePolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1584,19 +1584,19 @@ const deserializeAws_json1_1PutResourcePolicyCommandError = async (output, conte
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceQuotaExceededException":
         case "com.amazonaws.redshiftserverless#ServiceQuotaExceededException":
-            throw await deserializeAws_json1_1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1607,20 +1607,20 @@ const deserializeAws_json1_1PutResourcePolicyCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_json1_1RestoreFromRecoveryPointCommand = async (output, context) => {
+export const de_RestoreFromRecoveryPointCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1RestoreFromRecoveryPointCommandError(output, context);
+        return de_RestoreFromRecoveryPointCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1RestoreFromRecoveryPointResponse(data, context);
+    contents = de_RestoreFromRecoveryPointResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1RestoreFromRecoveryPointCommandError = async (output, context) => {
+const de_RestoreFromRecoveryPointCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1629,16 +1629,16 @@ const deserializeAws_json1_1RestoreFromRecoveryPointCommandError = async (output
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1649,20 +1649,20 @@ const deserializeAws_json1_1RestoreFromRecoveryPointCommandError = async (output
             });
     }
 };
-export const deserializeAws_json1_1RestoreFromSnapshotCommand = async (output, context) => {
+export const de_RestoreFromSnapshotCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1RestoreFromSnapshotCommandError(output, context);
+        return de_RestoreFromSnapshotCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1RestoreFromSnapshotResponse(data, context);
+    contents = de_RestoreFromSnapshotResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1RestoreFromSnapshotCommandError = async (output, context) => {
+const de_RestoreFromSnapshotCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1671,19 +1671,19 @@ const deserializeAws_json1_1RestoreFromSnapshotCommandError = async (output, con
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceQuotaExceededException":
         case "com.amazonaws.redshiftserverless#ServiceQuotaExceededException":
-            throw await deserializeAws_json1_1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1694,20 +1694,20 @@ const deserializeAws_json1_1RestoreFromSnapshotCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1RestoreTableFromSnapshotCommand = async (output, context) => {
+export const de_RestoreTableFromSnapshotCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1RestoreTableFromSnapshotCommandError(output, context);
+        return de_RestoreTableFromSnapshotCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1RestoreTableFromSnapshotResponse(data, context);
+    contents = de_RestoreTableFromSnapshotResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1RestoreTableFromSnapshotCommandError = async (output, context) => {
+const de_RestoreTableFromSnapshotCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1716,16 +1716,16 @@ const deserializeAws_json1_1RestoreTableFromSnapshotCommandError = async (output
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1736,20 +1736,20 @@ const deserializeAws_json1_1RestoreTableFromSnapshotCommandError = async (output
             });
     }
 };
-export const deserializeAws_json1_1TagResourceCommand = async (output, context) => {
+export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1TagResourceCommandError(output, context);
+        return de_TagResourceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1TagResourceResponse(data, context);
+    contents = de_TagResourceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1TagResourceCommandError = async (output, context) => {
+const de_TagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1758,19 +1758,19 @@ const deserializeAws_json1_1TagResourceCommandError = async (output, context) =>
     switch (errorCode) {
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.redshiftserverless#ThrottlingException":
-            throw await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.redshiftserverless#TooManyTagsException":
-            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1781,20 +1781,20 @@ const deserializeAws_json1_1TagResourceCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_json1_1UntagResourceCommand = async (output, context) => {
+export const de_UntagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UntagResourceCommandError(output, context);
+        return de_UntagResourceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UntagResourceResponse(data, context);
+    contents = de_UntagResourceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UntagResourceCommandError = async (output, context) => {
+const de_UntagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1803,16 +1803,16 @@ const deserializeAws_json1_1UntagResourceCommandError = async (output, context)
     switch (errorCode) {
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.redshiftserverless#ThrottlingException":
-            throw await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1823,20 +1823,20 @@ const deserializeAws_json1_1UntagResourceCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1UpdateEndpointAccessCommand = async (output, context) => {
+export const de_UpdateEndpointAccessCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UpdateEndpointAccessCommandError(output, context);
+        return de_UpdateEndpointAccessCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UpdateEndpointAccessResponse(data, context);
+    contents = de_UpdateEndpointAccessResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UpdateEndpointAccessCommandError = async (output, context) => {
+const de_UpdateEndpointAccessCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1845,19 +1845,19 @@ const deserializeAws_json1_1UpdateEndpointAccessCommandError = async (output, co
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.redshiftserverless#AccessDeniedException":
-            throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1868,20 +1868,20 @@ const deserializeAws_json1_1UpdateEndpointAccessCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_json1_1UpdateNamespaceCommand = async (output, context) => {
+export const de_UpdateNamespaceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UpdateNamespaceCommandError(output, context);
+        return de_UpdateNamespaceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UpdateNamespaceResponse(data, context);
+    contents = de_UpdateNamespaceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UpdateNamespaceCommandError = async (output, context) => {
+const de_UpdateNamespaceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1890,16 +1890,16 @@ const deserializeAws_json1_1UpdateNamespaceCommandError = async (output, context
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1910,20 +1910,20 @@ const deserializeAws_json1_1UpdateNamespaceCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_json1_1UpdateSnapshotCommand = async (output, context) => {
+export const de_UpdateSnapshotCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UpdateSnapshotCommandError(output, context);
+        return de_UpdateSnapshotCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UpdateSnapshotResponse(data, context);
+    contents = de_UpdateSnapshotResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UpdateSnapshotCommandError = async (output, context) => {
+const de_UpdateSnapshotCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1932,16 +1932,16 @@ const deserializeAws_json1_1UpdateSnapshotCommandError = async (output, context)
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1952,20 +1952,20 @@ const deserializeAws_json1_1UpdateSnapshotCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1UpdateUsageLimitCommand = async (output, context) => {
+export const de_UpdateUsageLimitCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UpdateUsageLimitCommandError(output, context);
+        return de_UpdateUsageLimitCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UpdateUsageLimitResponse(data, context);
+    contents = de_UpdateUsageLimitResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UpdateUsageLimitCommandError = async (output, context) => {
+const de_UpdateUsageLimitCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1974,16 +1974,16 @@ const deserializeAws_json1_1UpdateUsageLimitCommandError = async (output, contex
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1994,20 +1994,20 @@ const deserializeAws_json1_1UpdateUsageLimitCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1UpdateWorkgroupCommand = async (output, context) => {
+export const de_UpdateWorkgroupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UpdateWorkgroupCommandError(output, context);
+        return de_UpdateWorkgroupCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UpdateWorkgroupResponse(data, context);
+    contents = de_UpdateWorkgroupResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UpdateWorkgroupCommandError = async (output, context) => {
+const de_UpdateWorkgroupCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2016,19 +2016,19 @@ const deserializeAws_json1_1UpdateWorkgroupCommandError = async (output, context
     switch (errorCode) {
         case "ConflictException":
         case "com.amazonaws.redshiftserverless#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InsufficientCapacityException":
         case "com.amazonaws.redshiftserverless#InsufficientCapacityException":
-            throw await deserializeAws_json1_1InsufficientCapacityExceptionResponse(parsedOutput, context);
+            throw await de_InsufficientCapacityExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.redshiftserverless#InternalServerException":
-            throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.redshiftserverless#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.redshiftserverless#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2039,149 +2039,149 @@ const deserializeAws_json1_1UpdateWorkgroupCommandError = async (output, context
             });
     }
 };
-const deserializeAws_json1_1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
+const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1AccessDeniedException(body, context);
+    const deserialized = de_AccessDeniedException(body, context);
     const exception = new AccessDeniedException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ConflictExceptionResponse = async (parsedOutput, context) => {
+const de_ConflictExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ConflictException(body, context);
+    const deserialized = de_ConflictException(body, context);
     const exception = new ConflictException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InsufficientCapacityExceptionResponse = async (parsedOutput, context) => {
+const de_InsufficientCapacityExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InsufficientCapacityException(body, context);
+    const deserialized = de_InsufficientCapacityException(body, context);
     const exception = new InsufficientCapacityException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InternalServerExceptionResponse = async (parsedOutput, context) => {
+const de_InternalServerExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InternalServerException(body, context);
+    const deserialized = de_InternalServerException(body, context);
     const exception = new InternalServerException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InvalidPaginationExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidPaginationExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InvalidPaginationException(body, context);
+    const deserialized = de_InvalidPaginationException(body, context);
     const exception = new InvalidPaginationException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ResourceNotFoundException(body, context);
+    const deserialized = de_ResourceNotFoundException(body, context);
     const exception = new ResourceNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ServiceQuotaExceededExceptionResponse = async (parsedOutput, context) => {
+const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ServiceQuotaExceededException(body, context);
+    const deserialized = de_ServiceQuotaExceededException(body, context);
     const exception = new ServiceQuotaExceededException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ThrottlingExceptionResponse = async (parsedOutput, context) => {
+const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ThrottlingException(body, context);
+    const deserialized = de_ThrottlingException(body, context);
     const exception = new ThrottlingException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1TooManyTagsExceptionResponse = async (parsedOutput, context) => {
+const de_TooManyTagsExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1TooManyTagsException(body, context);
+    const deserialized = de_TooManyTagsException(body, context);
     const exception = new TooManyTagsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ValidationExceptionResponse = async (parsedOutput, context) => {
+const de_ValidationExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ValidationException(body, context);
+    const deserialized = de_ValidationException(body, context);
     const exception = new ValidationException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const serializeAws_json1_1ConfigParameter = (input, context) => {
+const se_ConfigParameter = (input, context) => {
     return {
         ...(input.parameterKey != null && { parameterKey: input.parameterKey }),
         ...(input.parameterValue != null && { parameterValue: input.parameterValue }),
     };
 };
-const serializeAws_json1_1ConfigParameterList = (input, context) => {
+const se_ConfigParameterList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1ConfigParameter(entry, context);
+        return se_ConfigParameter(entry, context);
     });
 };
-const serializeAws_json1_1ConvertRecoveryPointToSnapshotRequest = (input, context) => {
+const se_ConvertRecoveryPointToSnapshotRequest = (input, context) => {
     return {
         ...(input.recoveryPointId != null && { recoveryPointId: input.recoveryPointId }),
         ...(input.retentionPeriod != null && { retentionPeriod: input.retentionPeriod }),
         ...(input.snapshotName != null && { snapshotName: input.snapshotName }),
-        ...(input.tags != null && { tags: serializeAws_json1_1TagList(input.tags, context) }),
+        ...(input.tags != null && { tags: se_TagList(input.tags, context) }),
     };
 };
-const serializeAws_json1_1CreateEndpointAccessRequest = (input, context) => {
+const se_CreateEndpointAccessRequest = (input, context) => {
     return {
         ...(input.endpointName != null && { endpointName: input.endpointName }),
-        ...(input.subnetIds != null && { subnetIds: serializeAws_json1_1SubnetIdList(input.subnetIds, context) }),
+        ...(input.subnetIds != null && { subnetIds: se_SubnetIdList(input.subnetIds, context) }),
         ...(input.vpcSecurityGroupIds != null && {
-            vpcSecurityGroupIds: serializeAws_json1_1VpcSecurityGroupIdList(input.vpcSecurityGroupIds, context),
+            vpcSecurityGroupIds: se_VpcSecurityGroupIdList(input.vpcSecurityGroupIds, context),
         }),
         ...(input.workgroupName != null && { workgroupName: input.workgroupName }),
     };
 };
-const serializeAws_json1_1CreateNamespaceRequest = (input, context) => {
+const se_CreateNamespaceRequest = (input, context) => {
     return {
         ...(input.adminUserPassword != null && { adminUserPassword: input.adminUserPassword }),
         ...(input.adminUsername != null && { adminUsername: input.adminUsername }),
         ...(input.dbName != null && { dbName: input.dbName }),
         ...(input.defaultIamRoleArn != null && { defaultIamRoleArn: input.defaultIamRoleArn }),
-        ...(input.iamRoles != null && { iamRoles: serializeAws_json1_1IamRoleArnList(input.iamRoles, context) }),
+        ...(input.iamRoles != null && { iamRoles: se_IamRoleArnList(input.iamRoles, context) }),
         ...(input.kmsKeyId != null && { kmsKeyId: input.kmsKeyId }),
-        ...(input.logExports != null && { logExports: serializeAws_json1_1LogExportList(input.logExports, context) }),
+        ...(input.logExports != null && { logExports: se_LogExportList(input.logExports, context) }),
         ...(input.namespaceName != null && { namespaceName: input.namespaceName }),
-        ...(input.tags != null && { tags: serializeAws_json1_1TagList(input.tags, context) }),
+        ...(input.tags != null && { tags: se_TagList(input.tags, context) }),
     };
 };
-const serializeAws_json1_1CreateSnapshotRequest = (input, context) => {
+const se_CreateSnapshotRequest = (input, context) => {
     return {
         ...(input.namespaceName != null && { namespaceName: input.namespaceName }),
         ...(input.retentionPeriod != null && { retentionPeriod: input.retentionPeriod }),
         ...(input.snapshotName != null && { snapshotName: input.snapshotName }),
-        ...(input.tags != null && { tags: serializeAws_json1_1TagList(input.tags, context) }),
+        ...(input.tags != null && { tags: se_TagList(input.tags, context) }),
     };
 };
-const serializeAws_json1_1CreateUsageLimitRequest = (input, context) => {
+const se_CreateUsageLimitRequest = (input, context) => {
     return {
         ...(input.amount != null && { amount: input.amount }),
         ...(input.breachAction != null && { breachAction: input.breachAction }),
@@ -2190,30 +2190,30 @@ const serializeAws_json1_1CreateUsageLimitRequest = (input, context) => {
         ...(input.usageType != null && { usageType: input.usageType }),
     };
 };
-const serializeAws_json1_1CreateWorkgroupRequest = (input, context) => {
+const se_CreateWorkgroupRequest = (input, context) => {
     return {
         ...(input.baseCapacity != null && { baseCapacity: input.baseCapacity }),
         ...(input.configParameters != null && {
-            configParameters: serializeAws_json1_1ConfigParameterList(input.configParameters, context),
+            configParameters: se_ConfigParameterList(input.configParameters, context),
         }),
         ...(input.enhancedVpcRouting != null && { enhancedVpcRouting: input.enhancedVpcRouting }),
         ...(input.namespaceName != null && { namespaceName: input.namespaceName }),
         ...(input.port != null && { port: input.port }),
         ...(input.publiclyAccessible != null && { publiclyAccessible: input.publiclyAccessible }),
         ...(input.securityGroupIds != null && {
-            securityGroupIds: serializeAws_json1_1SecurityGroupIdList(input.securityGroupIds, context),
+            securityGroupIds: se_SecurityGroupIdList(input.securityGroupIds, context),
         }),
-        ...(input.subnetIds != null && { subnetIds: serializeAws_json1_1SubnetIdList(input.subnetIds, context) }),
-        ...(input.tags != null && { tags: serializeAws_json1_1TagList(input.tags, context) }),
+        ...(input.subnetIds != null && { subnetIds: se_SubnetIdList(input.subnetIds, context) }),
+        ...(input.tags != null && { tags: se_TagList(input.tags, context) }),
         ...(input.workgroupName != null && { workgroupName: input.workgroupName }),
     };
 };
-const serializeAws_json1_1DeleteEndpointAccessRequest = (input, context) => {
+const se_DeleteEndpointAccessRequest = (input, context) => {
     return {
         ...(input.endpointName != null && { endpointName: input.endpointName }),
     };
 };
-const serializeAws_json1_1DeleteNamespaceRequest = (input, context) => {
+const se_DeleteNamespaceRequest = (input, context) => {
     return {
         ...(input.finalSnapshotName != null && { finalSnapshotName: input.finalSnapshotName }),
         ...(input.finalSnapshotRetentionPeriod != null && {
@@ -2222,83 +2222,83 @@ const serializeAws_json1_1DeleteNamespaceRequest = (input, context) => {
         ...(input.namespaceName != null && { namespaceName: input.namespaceName }),
     };
 };
-const serializeAws_json1_1DeleteResourcePolicyRequest = (input, context) => {
+const se_DeleteResourcePolicyRequest = (input, context) => {
     return {
         ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
     };
 };
-const serializeAws_json1_1DeleteSnapshotRequest = (input, context) => {
+const se_DeleteSnapshotRequest = (input, context) => {
     return {
         ...(input.snapshotName != null && { snapshotName: input.snapshotName }),
     };
 };
-const serializeAws_json1_1DeleteUsageLimitRequest = (input, context) => {
+const se_DeleteUsageLimitRequest = (input, context) => {
     return {
         ...(input.usageLimitId != null && { usageLimitId: input.usageLimitId }),
     };
 };
-const serializeAws_json1_1DeleteWorkgroupRequest = (input, context) => {
+const se_DeleteWorkgroupRequest = (input, context) => {
     return {
         ...(input.workgroupName != null && { workgroupName: input.workgroupName }),
     };
 };
-const serializeAws_json1_1GetCredentialsRequest = (input, context) => {
+const se_GetCredentialsRequest = (input, context) => {
     return {
         ...(input.dbName != null && { dbName: input.dbName }),
         ...(input.durationSeconds != null && { durationSeconds: input.durationSeconds }),
         ...(input.workgroupName != null && { workgroupName: input.workgroupName }),
     };
 };
-const serializeAws_json1_1GetEndpointAccessRequest = (input, context) => {
+const se_GetEndpointAccessRequest = (input, context) => {
     return {
         ...(input.endpointName != null && { endpointName: input.endpointName }),
     };
 };
-const serializeAws_json1_1GetNamespaceRequest = (input, context) => {
+const se_GetNamespaceRequest = (input, context) => {
     return {
         ...(input.namespaceName != null && { namespaceName: input.namespaceName }),
     };
 };
-const serializeAws_json1_1GetRecoveryPointRequest = (input, context) => {
+const se_GetRecoveryPointRequest = (input, context) => {
     return {
         ...(input.recoveryPointId != null && { recoveryPointId: input.recoveryPointId }),
     };
 };
-const serializeAws_json1_1GetResourcePolicyRequest = (input, context) => {
+const se_GetResourcePolicyRequest = (input, context) => {
     return {
         ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
     };
 };
-const serializeAws_json1_1GetSnapshotRequest = (input, context) => {
+const se_GetSnapshotRequest = (input, context) => {
     return {
         ...(input.ownerAccount != null && { ownerAccount: input.ownerAccount }),
         ...(input.snapshotArn != null && { snapshotArn: input.snapshotArn }),
         ...(input.snapshotName != null && { snapshotName: input.snapshotName }),
     };
 };
-const serializeAws_json1_1GetTableRestoreStatusRequest = (input, context) => {
+const se_GetTableRestoreStatusRequest = (input, context) => {
     return {
         ...(input.tableRestoreRequestId != null && { tableRestoreRequestId: input.tableRestoreRequestId }),
     };
 };
-const serializeAws_json1_1GetUsageLimitRequest = (input, context) => {
+const se_GetUsageLimitRequest = (input, context) => {
     return {
         ...(input.usageLimitId != null && { usageLimitId: input.usageLimitId }),
     };
 };
-const serializeAws_json1_1GetWorkgroupRequest = (input, context) => {
+const se_GetWorkgroupRequest = (input, context) => {
     return {
         ...(input.workgroupName != null && { workgroupName: input.workgroupName }),
     };
 };
-const serializeAws_json1_1IamRoleArnList = (input, context) => {
+const se_IamRoleArnList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1ListEndpointAccessRequest = (input, context) => {
+const se_ListEndpointAccessRequest = (input, context) => {
     return {
         ...(input.maxResults != null && { maxResults: input.maxResults }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
@@ -2306,13 +2306,13 @@ const serializeAws_json1_1ListEndpointAccessRequest = (input, context) => {
         ...(input.workgroupName != null && { workgroupName: input.workgroupName }),
     };
 };
-const serializeAws_json1_1ListNamespacesRequest = (input, context) => {
+const se_ListNamespacesRequest = (input, context) => {
     return {
         ...(input.maxResults != null && { maxResults: input.maxResults }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
     };
 };
-const serializeAws_json1_1ListRecoveryPointsRequest = (input, context) => {
+const se_ListRecoveryPointsRequest = (input, context) => {
     return {
         ...(input.endTime != null && { endTime: Math.round(input.endTime.getTime() / 1000) }),
         ...(input.maxResults != null && { maxResults: input.maxResults }),
@@ -2322,7 +2322,7 @@ const serializeAws_json1_1ListRecoveryPointsRequest = (input, context) => {
         ...(input.startTime != null && { startTime: Math.round(input.startTime.getTime() / 1000) }),
     };
 };
-const serializeAws_json1_1ListSnapshotsRequest = (input, context) => {
+const se_ListSnapshotsRequest = (input, context) => {
     return {
         ...(input.endTime != null && { endTime: Math.round(input.endTime.getTime() / 1000) }),
         ...(input.maxResults != null && { maxResults: input.maxResults }),
@@ -2333,7 +2333,7 @@ const serializeAws_json1_1ListSnapshotsRequest = (input, context) => {
         ...(input.startTime != null && { startTime: Math.round(input.startTime.getTime() / 1000) }),
     };
 };
-const serializeAws_json1_1ListTableRestoreStatusRequest = (input, context) => {
+const se_ListTableRestoreStatusRequest = (input, context) => {
     return {
         ...(input.maxResults != null && { maxResults: input.maxResults }),
         ...(input.namespaceName != null && { namespaceName: input.namespaceName }),
@@ -2341,12 +2341,12 @@ const serializeAws_json1_1ListTableRestoreStatusRequest = (input, context) => {
         ...(input.workgroupName != null && { workgroupName: input.workgroupName }),
     };
 };
-const serializeAws_json1_1ListTagsForResourceRequest = (input, context) => {
+const se_ListTagsForResourceRequest = (input, context) => {
     return {
         ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
     };
 };
-const serializeAws_json1_1ListUsageLimitsRequest = (input, context) => {
+const se_ListUsageLimitsRequest = (input, context) => {
     return {
         ...(input.maxResults != null && { maxResults: input.maxResults }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
@@ -2354,33 +2354,33 @@ const serializeAws_json1_1ListUsageLimitsRequest = (input, context) => {
         ...(input.usageType != null && { usageType: input.usageType }),
     };
 };
-const serializeAws_json1_1ListWorkgroupsRequest = (input, context) => {
+const se_ListWorkgroupsRequest = (input, context) => {
     return {
         ...(input.maxResults != null && { maxResults: input.maxResults }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
     };
 };
-const serializeAws_json1_1LogExportList = (input, context) => {
+const se_LogExportList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1PutResourcePolicyRequest = (input, context) => {
+const se_PutResourcePolicyRequest = (input, context) => {
     return {
         ...(input.policy != null && { policy: input.policy }),
         ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
     };
 };
-const serializeAws_json1_1RestoreFromRecoveryPointRequest = (input, context) => {
+const se_RestoreFromRecoveryPointRequest = (input, context) => {
     return {
         ...(input.namespaceName != null && { namespaceName: input.namespaceName }),
         ...(input.recoveryPointId != null && { recoveryPointId: input.recoveryPointId }),
         ...(input.workgroupName != null && { workgroupName: input.workgroupName }),
     };
 };
-const serializeAws_json1_1RestoreFromSnapshotRequest = (input, context) => {
+const se_RestoreFromSnapshotRequest = (input, context) => {
     return {
         ...(input.namespaceName != null && { namespaceName: input.namespaceName }),
         ...(input.ownerAccount != null && { ownerAccount: input.ownerAccount }),
@@ -2389,7 +2389,7 @@ const serializeAws_json1_1RestoreFromSnapshotRequest = (input, context) => {
         ...(input.workgroupName != null && { workgroupName: input.workgroupName }),
     };
 };
-const serializeAws_json1_1RestoreTableFromSnapshotRequest = (input, context) => {
+const se_RestoreTableFromSnapshotRequest = (input, context) => {
     return {
         ...(input.activateCaseSensitiveIdentifier != null && {
             activateCaseSensitiveIdentifier: input.activateCaseSensitiveIdentifier,
@@ -2405,114 +2405,114 @@ const serializeAws_json1_1RestoreTableFromSnapshotRequest = (input, context) =>
         ...(input.workgroupName != null && { workgroupName: input.workgroupName }),
     };
 };
-const serializeAws_json1_1SecurityGroupIdList = (input, context) => {
+const se_SecurityGroupIdList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1SubnetIdList = (input, context) => {
+const se_SubnetIdList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1Tag = (input, context) => {
+const se_Tag = (input, context) => {
     return {
         ...(input.key != null && { key: input.key }),
         ...(input.value != null && { value: input.value }),
     };
 };
-const serializeAws_json1_1TagKeyList = (input, context) => {
+const se_TagKeyList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1TagList = (input, context) => {
+const se_TagList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1Tag(entry, context);
+        return se_Tag(entry, context);
     });
 };
-const serializeAws_json1_1TagResourceRequest = (input, context) => {
+const se_TagResourceRequest = (input, context) => {
     return {
         ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
-        ...(input.tags != null && { tags: serializeAws_json1_1TagList(input.tags, context) }),
+        ...(input.tags != null && { tags: se_TagList(input.tags, context) }),
     };
 };
-const serializeAws_json1_1UntagResourceRequest = (input, context) => {
+const se_UntagResourceRequest = (input, context) => {
     return {
         ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
-        ...(input.tagKeys != null && { tagKeys: serializeAws_json1_1TagKeyList(input.tagKeys, context) }),
+        ...(input.tagKeys != null && { tagKeys: se_TagKeyList(input.tagKeys, context) }),
     };
 };
-const serializeAws_json1_1UpdateEndpointAccessRequest = (input, context) => {
+const se_UpdateEndpointAccessRequest = (input, context) => {
     return {
         ...(input.endpointName != null && { endpointName: input.endpointName }),
         ...(input.vpcSecurityGroupIds != null && {
-            vpcSecurityGroupIds: serializeAws_json1_1VpcSecurityGroupIdList(input.vpcSecurityGroupIds, context),
+            vpcSecurityGroupIds: se_VpcSecurityGroupIdList(input.vpcSecurityGroupIds, context),
         }),
     };
 };
-const serializeAws_json1_1UpdateNamespaceRequest = (input, context) => {
+const se_UpdateNamespaceRequest = (input, context) => {
     return {
         ...(input.adminUserPassword != null && { adminUserPassword: input.adminUserPassword }),
         ...(input.adminUsername != null && { adminUsername: input.adminUsername }),
         ...(input.defaultIamRoleArn != null && { defaultIamRoleArn: input.defaultIamRoleArn }),
-        ...(input.iamRoles != null && { iamRoles: serializeAws_json1_1IamRoleArnList(input.iamRoles, context) }),
+        ...(input.iamRoles != null && { iamRoles: se_IamRoleArnList(input.iamRoles, context) }),
         ...(input.kmsKeyId != null && { kmsKeyId: input.kmsKeyId }),
-        ...(input.logExports != null && { logExports: serializeAws_json1_1LogExportList(input.logExports, context) }),
+        ...(input.logExports != null && { logExports: se_LogExportList(input.logExports, context) }),
         ...(input.namespaceName != null && { namespaceName: input.namespaceName }),
     };
 };
-const serializeAws_json1_1UpdateSnapshotRequest = (input, context) => {
+const se_UpdateSnapshotRequest = (input, context) => {
     return {
         ...(input.retentionPeriod != null && { retentionPeriod: input.retentionPeriod }),
         ...(input.snapshotName != null && { snapshotName: input.snapshotName }),
     };
 };
-const serializeAws_json1_1UpdateUsageLimitRequest = (input, context) => {
+const se_UpdateUsageLimitRequest = (input, context) => {
     return {
         ...(input.amount != null && { amount: input.amount }),
         ...(input.breachAction != null && { breachAction: input.breachAction }),
         ...(input.usageLimitId != null && { usageLimitId: input.usageLimitId }),
     };
 };
-const serializeAws_json1_1UpdateWorkgroupRequest = (input, context) => {
+const se_UpdateWorkgroupRequest = (input, context) => {
     return {
         ...(input.baseCapacity != null && { baseCapacity: input.baseCapacity }),
         ...(input.configParameters != null && {
-            configParameters: serializeAws_json1_1ConfigParameterList(input.configParameters, context),
+            configParameters: se_ConfigParameterList(input.configParameters, context),
         }),
         ...(input.enhancedVpcRouting != null && { enhancedVpcRouting: input.enhancedVpcRouting }),
         ...(input.port != null && { port: input.port }),
         ...(input.publiclyAccessible != null && { publiclyAccessible: input.publiclyAccessible }),
         ...(input.securityGroupIds != null && {
-            securityGroupIds: serializeAws_json1_1SecurityGroupIdList(input.securityGroupIds, context),
+            securityGroupIds: se_SecurityGroupIdList(input.securityGroupIds, context),
         }),
-        ...(input.subnetIds != null && { subnetIds: serializeAws_json1_1SubnetIdList(input.subnetIds, context) }),
+        ...(input.subnetIds != null && { subnetIds: se_SubnetIdList(input.subnetIds, context) }),
         ...(input.workgroupName != null && { workgroupName: input.workgroupName }),
     };
 };
-const serializeAws_json1_1VpcSecurityGroupIdList = (input, context) => {
+const se_VpcSecurityGroupIdList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const deserializeAws_json1_1AccessDeniedException = (output, context) => {
+const de_AccessDeniedException = (output, context) => {
     return {
         code: __expectString(output.code),
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1AccountIdList = (output, context) => {
+const de_AccountIdList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2523,94 +2523,94 @@ const deserializeAws_json1_1AccountIdList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1ConfigParameter = (output, context) => {
+const de_ConfigParameter = (output, context) => {
     return {
         parameterKey: __expectString(output.parameterKey),
         parameterValue: __expectString(output.parameterValue),
     };
 };
-const deserializeAws_json1_1ConfigParameterList = (output, context) => {
+const de_ConfigParameterList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ConfigParameter(entry, context);
+        return de_ConfigParameter(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ConflictException = (output, context) => {
+const de_ConflictException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ConvertRecoveryPointToSnapshotResponse = (output, context) => {
+const de_ConvertRecoveryPointToSnapshotResponse = (output, context) => {
     return {
-        snapshot: output.snapshot != null ? deserializeAws_json1_1Snapshot(output.snapshot, context) : undefined,
+        snapshot: output.snapshot != null ? de_Snapshot(output.snapshot, context) : undefined,
     };
 };
-const deserializeAws_json1_1CreateEndpointAccessResponse = (output, context) => {
+const de_CreateEndpointAccessResponse = (output, context) => {
     return {
-        endpoint: output.endpoint != null ? deserializeAws_json1_1EndpointAccess(output.endpoint, context) : undefined,
+        endpoint: output.endpoint != null ? de_EndpointAccess(output.endpoint, context) : undefined,
     };
 };
-const deserializeAws_json1_1CreateNamespaceResponse = (output, context) => {
+const de_CreateNamespaceResponse = (output, context) => {
     return {
-        namespace: output.namespace != null ? deserializeAws_json1_1Namespace(output.namespace, context) : undefined,
+        namespace: output.namespace != null ? de_Namespace(output.namespace, context) : undefined,
     };
 };
-const deserializeAws_json1_1CreateSnapshotResponse = (output, context) => {
+const de_CreateSnapshotResponse = (output, context) => {
     return {
-        snapshot: output.snapshot != null ? deserializeAws_json1_1Snapshot(output.snapshot, context) : undefined,
+        snapshot: output.snapshot != null ? de_Snapshot(output.snapshot, context) : undefined,
     };
 };
-const deserializeAws_json1_1CreateUsageLimitResponse = (output, context) => {
+const de_CreateUsageLimitResponse = (output, context) => {
     return {
-        usageLimit: output.usageLimit != null ? deserializeAws_json1_1UsageLimit(output.usageLimit, context) : undefined,
+        usageLimit: output.usageLimit != null ? de_UsageLimit(output.usageLimit, context) : undefined,
     };
 };
-const deserializeAws_json1_1CreateWorkgroupResponse = (output, context) => {
+const de_CreateWorkgroupResponse = (output, context) => {
     return {
-        workgroup: output.workgroup != null ? deserializeAws_json1_1Workgroup(output.workgroup, context) : undefined,
+        workgroup: output.workgroup != null ? de_Workgroup(output.workgroup, context) : undefined,
     };
 };
-const deserializeAws_json1_1DeleteEndpointAccessResponse = (output, context) => {
+const de_DeleteEndpointAccessResponse = (output, context) => {
     return {
-        endpoint: output.endpoint != null ? deserializeAws_json1_1EndpointAccess(output.endpoint, context) : undefined,
+        endpoint: output.endpoint != null ? de_EndpointAccess(output.endpoint, context) : undefined,
     };
 };
-const deserializeAws_json1_1DeleteNamespaceResponse = (output, context) => {
+const de_DeleteNamespaceResponse = (output, context) => {
     return {
-        namespace: output.namespace != null ? deserializeAws_json1_1Namespace(output.namespace, context) : undefined,
+        namespace: output.namespace != null ? de_Namespace(output.namespace, context) : undefined,
     };
 };
-const deserializeAws_json1_1DeleteResourcePolicyResponse = (output, context) => {
+const de_DeleteResourcePolicyResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1DeleteSnapshotResponse = (output, context) => {
+const de_DeleteSnapshotResponse = (output, context) => {
     return {
-        snapshot: output.snapshot != null ? deserializeAws_json1_1Snapshot(output.snapshot, context) : undefined,
+        snapshot: output.snapshot != null ? de_Snapshot(output.snapshot, context) : undefined,
     };
 };
-const deserializeAws_json1_1DeleteUsageLimitResponse = (output, context) => {
+const de_DeleteUsageLimitResponse = (output, context) => {
     return {
-        usageLimit: output.usageLimit != null ? deserializeAws_json1_1UsageLimit(output.usageLimit, context) : undefined,
+        usageLimit: output.usageLimit != null ? de_UsageLimit(output.usageLimit, context) : undefined,
     };
 };
-const deserializeAws_json1_1DeleteWorkgroupResponse = (output, context) => {
+const de_DeleteWorkgroupResponse = (output, context) => {
     return {
-        workgroup: output.workgroup != null ? deserializeAws_json1_1Workgroup(output.workgroup, context) : undefined,
+        workgroup: output.workgroup != null ? de_Workgroup(output.workgroup, context) : undefined,
     };
 };
-const deserializeAws_json1_1Endpoint = (output, context) => {
+const de_Endpoint = (output, context) => {
     return {
         address: __expectString(output.address),
         port: __expectInt32(output.port),
-        vpcEndpoints: output.vpcEndpoints != null ? deserializeAws_json1_1VpcEndpointList(output.vpcEndpoints, context) : undefined,
+        vpcEndpoints: output.vpcEndpoints != null ? de_VpcEndpointList(output.vpcEndpoints, context) : undefined,
     };
 };
-const deserializeAws_json1_1EndpointAccess = (output, context) => {
+const de_EndpointAccess = (output, context) => {
     return {
         address: __expectString(output.address),
         endpointArn: __expectString(output.endpointArn),
@@ -2620,26 +2620,26 @@ const deserializeAws_json1_1EndpointAccess = (output, context) => {
         endpointName: __expectString(output.endpointName),
         endpointStatus: __expectString(output.endpointStatus),
         port: __expectInt32(output.port),
-        subnetIds: output.subnetIds != null ? deserializeAws_json1_1SubnetIdList(output.subnetIds, context) : undefined,
-        vpcEndpoint: output.vpcEndpoint != null ? deserializeAws_json1_1VpcEndpoint(output.vpcEndpoint, context) : undefined,
+        subnetIds: output.subnetIds != null ? de_SubnetIdList(output.subnetIds, context) : undefined,
+        vpcEndpoint: output.vpcEndpoint != null ? de_VpcEndpoint(output.vpcEndpoint, context) : undefined,
         vpcSecurityGroups: output.vpcSecurityGroups != null
-            ? deserializeAws_json1_1VpcSecurityGroupMembershipList(output.vpcSecurityGroups, context)
+            ? de_VpcSecurityGroupMembershipList(output.vpcSecurityGroups, context)
             : undefined,
         workgroupName: __expectString(output.workgroupName),
     };
 };
-const deserializeAws_json1_1EndpointAccessList = (output, context) => {
+const de_EndpointAccessList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1EndpointAccess(entry, context);
+        return de_EndpointAccess(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1GetCredentialsResponse = (output, context) => {
+const de_GetCredentialsResponse = (output, context) => {
     return {
         dbPassword: __expectString(output.dbPassword),
         dbUser: __expectString(output.dbUser),
@@ -2649,49 +2649,47 @@ const deserializeAws_json1_1GetCredentialsResponse = (output, context) => {
             : undefined,
     };
 };
-const deserializeAws_json1_1GetEndpointAccessResponse = (output, context) => {
+const de_GetEndpointAccessResponse = (output, context) => {
     return {
-        endpoint: output.endpoint != null ? deserializeAws_json1_1EndpointAccess(output.endpoint, context) : undefined,
+        endpoint: output.endpoint != null ? de_EndpointAccess(output.endpoint, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetNamespaceResponse = (output, context) => {
+const de_GetNamespaceResponse = (output, context) => {
     return {
-        namespace: output.namespace != null ? deserializeAws_json1_1Namespace(output.namespace, context) : undefined,
+        namespace: output.namespace != null ? de_Namespace(output.namespace, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetRecoveryPointResponse = (output, context) => {
+const de_GetRecoveryPointResponse = (output, context) => {
     return {
-        recoveryPoint: output.recoveryPoint != null ? deserializeAws_json1_1RecoveryPoint(output.recoveryPoint, context) : undefined,
+        recoveryPoint: output.recoveryPoint != null ? de_RecoveryPoint(output.recoveryPoint, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetResourcePolicyResponse = (output, context) => {
+const de_GetResourcePolicyResponse = (output, context) => {
     return {
-        resourcePolicy: output.resourcePolicy != null ? deserializeAws_json1_1ResourcePolicy(output.resourcePolicy, context) : undefined,
+        resourcePolicy: output.resourcePolicy != null ? de_ResourcePolicy(output.resourcePolicy, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetSnapshotResponse = (output, context) => {
+const de_GetSnapshotResponse = (output, context) => {
     return {
-        snapshot: output.snapshot != null ? deserializeAws_json1_1Snapshot(output.snapshot, context) : undefined,
+        snapshot: output.snapshot != null ? de_Snapshot(output.snapshot, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetTableRestoreStatusResponse = (output, context) => {
+const de_GetTableRestoreStatusResponse = (output, context) => {
     return {
-        tableRestoreStatus: output.tableRestoreStatus != null
-            ? deserializeAws_json1_1TableRestoreStatus(output.tableRestoreStatus, context)
-            : undefined,
+        tableRestoreStatus: output.tableRestoreStatus != null ? de_TableRestoreStatus(output.tableRestoreStatus, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetUsageLimitResponse = (output, context) => {
+const de_GetUsageLimitResponse = (output, context) => {
     return {
-        usageLimit: output.usageLimit != null ? deserializeAws_json1_1UsageLimit(output.usageLimit, context) : undefined,
+        usageLimit: output.usageLimit != null ? de_UsageLimit(output.usageLimit, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetWorkgroupResponse = (output, context) => {
+const de_GetWorkgroupResponse = (output, context) => {
     return {
-        workgroup: output.workgroup != null ? deserializeAws_json1_1Workgroup(output.workgroup, context) : undefined,
+        workgroup: output.workgroup != null ? de_Workgroup(output.workgroup, context) : undefined,
     };
 };
-const deserializeAws_json1_1IamRoleArnList = (output, context) => {
+const de_IamRoleArnList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2702,73 +2700,69 @@ const deserializeAws_json1_1IamRoleArnList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1InsufficientCapacityException = (output, context) => {
+const de_InsufficientCapacityException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1InternalServerException = (output, context) => {
+const de_InternalServerException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1InvalidPaginationException = (output, context) => {
+const de_InvalidPaginationException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ListEndpointAccessResponse = (output, context) => {
+const de_ListEndpointAccessResponse = (output, context) => {
     return {
-        endpoints: output.endpoints != null ? deserializeAws_json1_1EndpointAccessList(output.endpoints, context) : undefined,
+        endpoints: output.endpoints != null ? de_EndpointAccessList(output.endpoints, context) : undefined,
         nextToken: __expectString(output.nextToken),
     };
 };
-const deserializeAws_json1_1ListNamespacesResponse = (output, context) => {
+const de_ListNamespacesResponse = (output, context) => {
     return {
-        namespaces: output.namespaces != null ? deserializeAws_json1_1NamespaceList(output.namespaces, context) : undefined,
+        namespaces: output.namespaces != null ? de_NamespaceList(output.namespaces, context) : undefined,
         nextToken: __expectString(output.nextToken),
     };
 };
-const deserializeAws_json1_1ListRecoveryPointsResponse = (output, context) => {
+const de_ListRecoveryPointsResponse = (output, context) => {
     return {
         nextToken: __expectString(output.nextToken),
-        recoveryPoints: output.recoveryPoints != null
-            ? deserializeAws_json1_1RecoveryPointList(output.recoveryPoints, context)
-            : undefined,
+        recoveryPoints: output.recoveryPoints != null ? de_RecoveryPointList(output.recoveryPoints, context) : undefined,
     };
 };
-const deserializeAws_json1_1ListSnapshotsResponse = (output, context) => {
+const de_ListSnapshotsResponse = (output, context) => {
     return {
         nextToken: __expectString(output.nextToken),
-        snapshots: output.snapshots != null ? deserializeAws_json1_1SnapshotList(output.snapshots, context) : undefined,
+        snapshots: output.snapshots != null ? de_SnapshotList(output.snapshots, context) : undefined,
     };
 };
-const deserializeAws_json1_1ListTableRestoreStatusResponse = (output, context) => {
+const de_ListTableRestoreStatusResponse = (output, context) => {
     return {
         nextToken: __expectString(output.nextToken),
-        tableRestoreStatuses: output.tableRestoreStatuses != null
-            ? deserializeAws_json1_1TableRestoreStatusList(output.tableRestoreStatuses, context)
-            : undefined,
+        tableRestoreStatuses: output.tableRestoreStatuses != null ? de_TableRestoreStatusList(output.tableRestoreStatuses, context) : undefined,
     };
 };
-const deserializeAws_json1_1ListTagsForResourceResponse = (output, context) => {
+const de_ListTagsForResourceResponse = (output, context) => {
     return {
-        tags: output.tags != null ? deserializeAws_json1_1TagList(output.tags, context) : undefined,
+        tags: output.tags != null ? de_TagList(output.tags, context) : undefined,
     };
 };
-const deserializeAws_json1_1ListUsageLimitsResponse = (output, context) => {
+const de_ListUsageLimitsResponse = (output, context) => {
     return {
         nextToken: __expectString(output.nextToken),
-        usageLimits: output.usageLimits != null ? deserializeAws_json1_1UsageLimits(output.usageLimits, context) : undefined,
+        usageLimits: output.usageLimits != null ? de_UsageLimits(output.usageLimits, context) : undefined,
     };
 };
-const deserializeAws_json1_1ListWorkgroupsResponse = (output, context) => {
+const de_ListWorkgroupsResponse = (output, context) => {
     return {
         nextToken: __expectString(output.nextToken),
-        workgroups: output.workgroups != null ? deserializeAws_json1_1WorkgroupList(output.workgroups, context) : undefined,
+        workgroups: output.workgroups != null ? de_WorkgroupList(output.workgroups, context) : undefined,
     };
 };
-const deserializeAws_json1_1LogExportList = (output, context) => {
+const de_LogExportList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2779,33 +2773,33 @@ const deserializeAws_json1_1LogExportList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1Namespace = (output, context) => {
+const de_Namespace = (output, context) => {
     return {
         adminUsername: __expectString(output.adminUsername),
         creationDate: output.creationDate != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.creationDate)) : undefined,
         dbName: __expectString(output.dbName),
         defaultIamRoleArn: __expectString(output.defaultIamRoleArn),
-        iamRoles: output.iamRoles != null ? deserializeAws_json1_1IamRoleArnList(output.iamRoles, context) : undefined,
+        iamRoles: output.iamRoles != null ? de_IamRoleArnList(output.iamRoles, context) : undefined,
         kmsKeyId: __expectString(output.kmsKeyId),
-        logExports: output.logExports != null ? deserializeAws_json1_1LogExportList(output.logExports, context) : undefined,
+        logExports: output.logExports != null ? de_LogExportList(output.logExports, context) : undefined,
         namespaceArn: __expectString(output.namespaceArn),
         namespaceId: __expectString(output.namespaceId),
         namespaceName: __expectString(output.namespaceName),
         status: __expectString(output.status),
     };
 };
-const deserializeAws_json1_1NamespaceList = (output, context) => {
+const de_NamespaceList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Namespace(entry, context);
+        return de_Namespace(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1NetworkInterface = (output, context) => {
+const de_NetworkInterface = (output, context) => {
     return {
         availabilityZone: __expectString(output.availabilityZone),
         networkInterfaceId: __expectString(output.networkInterfaceId),
@@ -2813,23 +2807,23 @@ const deserializeAws_json1_1NetworkInterface = (output, context) => {
         subnetId: __expectString(output.subnetId),
     };
 };
-const deserializeAws_json1_1NetworkInterfaceList = (output, context) => {
+const de_NetworkInterfaceList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1NetworkInterface(entry, context);
+        return de_NetworkInterface(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1PutResourcePolicyResponse = (output, context) => {
+const de_PutResourcePolicyResponse = (output, context) => {
     return {
-        resourcePolicy: output.resourcePolicy != null ? deserializeAws_json1_1ResourcePolicy(output.resourcePolicy, context) : undefined,
+        resourcePolicy: output.resourcePolicy != null ? de_ResourcePolicy(output.resourcePolicy, context) : undefined,
     };
 };
-const deserializeAws_json1_1RecoveryPoint = (output, context) => {
+const de_RecoveryPoint = (output, context) => {
     return {
         namespaceArn: __expectString(output.namespaceArn),
         namespaceName: __expectString(output.namespaceName),
@@ -2841,50 +2835,48 @@ const deserializeAws_json1_1RecoveryPoint = (output, context) => {
         workgroupName: __expectString(output.workgroupName),
     };
 };
-const deserializeAws_json1_1RecoveryPointList = (output, context) => {
+const de_RecoveryPointList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1RecoveryPoint(entry, context);
+        return de_RecoveryPoint(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ResourceNotFoundException = (output, context) => {
+const de_ResourceNotFoundException = (output, context) => {
     return {
         message: __expectString(output.message),
         resourceName: __expectString(output.resourceName),
     };
 };
-const deserializeAws_json1_1ResourcePolicy = (output, context) => {
+const de_ResourcePolicy = (output, context) => {
     return {
         policy: __expectString(output.policy),
         resourceArn: __expectString(output.resourceArn),
     };
 };
-const deserializeAws_json1_1RestoreFromRecoveryPointResponse = (output, context) => {
+const de_RestoreFromRecoveryPointResponse = (output, context) => {
     return {
-        namespace: output.namespace != null ? deserializeAws_json1_1Namespace(output.namespace, context) : undefined,
+        namespace: output.namespace != null ? de_Namespace(output.namespace, context) : undefined,
         recoveryPointId: __expectString(output.recoveryPointId),
     };
 };
-const deserializeAws_json1_1RestoreFromSnapshotResponse = (output, context) => {
+const de_RestoreFromSnapshotResponse = (output, context) => {
     return {
-        namespace: output.namespace != null ? deserializeAws_json1_1Namespace(output.namespace, context) : undefined,
+        namespace: output.namespace != null ? de_Namespace(output.namespace, context) : undefined,
         ownerAccount: __expectString(output.ownerAccount),
         snapshotName: __expectString(output.snapshotName),
     };
 };
-const deserializeAws_json1_1RestoreTableFromSnapshotResponse = (output, context) => {
+const de_RestoreTableFromSnapshotResponse = (output, context) => {
     return {
-        tableRestoreStatus: output.tableRestoreStatus != null
-            ? deserializeAws_json1_1TableRestoreStatus(output.tableRestoreStatus, context)
-            : undefined,
+        tableRestoreStatus: output.tableRestoreStatus != null ? de_TableRestoreStatus(output.tableRestoreStatus, context) : undefined,
     };
 };
-const deserializeAws_json1_1SecurityGroupIdList = (output, context) => {
+const de_SecurityGroupIdList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2895,18 +2887,18 @@ const deserializeAws_json1_1SecurityGroupIdList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1ServiceQuotaExceededException = (output, context) => {
+const de_ServiceQuotaExceededException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1Snapshot = (output, context) => {
+const de_Snapshot = (output, context) => {
     return {
         accountsWithProvisionedRestoreAccess: output.accountsWithProvisionedRestoreAccess != null
-            ? deserializeAws_json1_1AccountIdList(output.accountsWithProvisionedRestoreAccess, context)
+            ? de_AccountIdList(output.accountsWithProvisionedRestoreAccess, context)
             : undefined,
         accountsWithRestoreAccess: output.accountsWithRestoreAccess != null
-            ? deserializeAws_json1_1AccountIdList(output.accountsWithRestoreAccess, context)
+            ? de_AccountIdList(output.accountsWithRestoreAccess, context)
             : undefined,
         actualIncrementalBackupSizeInMegaBytes: __limitedParseDouble(output.actualIncrementalBackupSizeInMegaBytes),
         adminUsername: __expectString(output.adminUsername),
@@ -2932,18 +2924,18 @@ const deserializeAws_json1_1Snapshot = (output, context) => {
         totalBackupSizeInMegaBytes: __limitedParseDouble(output.totalBackupSizeInMegaBytes),
     };
 };
-const deserializeAws_json1_1SnapshotList = (output, context) => {
+const de_SnapshotList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Snapshot(entry, context);
+        return de_Snapshot(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1SubnetIdList = (output, context) => {
+const de_SubnetIdList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2954,7 +2946,7 @@ const deserializeAws_json1_1SubnetIdList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1TableRestoreStatus = (output, context) => {
+const de_TableRestoreStatus = (output, context) => {
     return {
         message: __expectString(output.message),
         namespaceName: __expectString(output.namespaceName),
@@ -2975,78 +2967,78 @@ const deserializeAws_json1_1TableRestoreStatus = (output, context) => {
         workgroupName: __expectString(output.workgroupName),
     };
 };
-const deserializeAws_json1_1TableRestoreStatusList = (output, context) => {
+const de_TableRestoreStatusList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1TableRestoreStatus(entry, context);
+        return de_TableRestoreStatus(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1Tag = (output, context) => {
+const de_Tag = (output, context) => {
     return {
         key: __expectString(output.key),
         value: __expectString(output.value),
     };
 };
-const deserializeAws_json1_1TagList = (output, context) => {
+const de_TagList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Tag(entry, context);
+        return de_Tag(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1TagResourceResponse = (output, context) => {
+const de_TagResourceResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1ThrottlingException = (output, context) => {
+const de_ThrottlingException = (output, context) => {
     return {
         code: __expectString(output.code),
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1TooManyTagsException = (output, context) => {
+const de_TooManyTagsException = (output, context) => {
     return {
         message: __expectString(output.message),
         resourceName: __expectString(output.resourceName),
     };
 };
-const deserializeAws_json1_1UntagResourceResponse = (output, context) => {
+const de_UntagResourceResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1UpdateEndpointAccessResponse = (output, context) => {
+const de_UpdateEndpointAccessResponse = (output, context) => {
     return {
-        endpoint: output.endpoint != null ? deserializeAws_json1_1EndpointAccess(output.endpoint, context) : undefined,
+        endpoint: output.endpoint != null ? de_EndpointAccess(output.endpoint, context) : undefined,
     };
 };
-const deserializeAws_json1_1UpdateNamespaceResponse = (output, context) => {
+const de_UpdateNamespaceResponse = (output, context) => {
     return {
-        namespace: output.namespace != null ? deserializeAws_json1_1Namespace(output.namespace, context) : undefined,
+        namespace: output.namespace != null ? de_Namespace(output.namespace, context) : undefined,
     };
 };
-const deserializeAws_json1_1UpdateSnapshotResponse = (output, context) => {
+const de_UpdateSnapshotResponse = (output, context) => {
     return {
-        snapshot: output.snapshot != null ? deserializeAws_json1_1Snapshot(output.snapshot, context) : undefined,
+        snapshot: output.snapshot != null ? de_Snapshot(output.snapshot, context) : undefined,
     };
 };
-const deserializeAws_json1_1UpdateUsageLimitResponse = (output, context) => {
+const de_UpdateUsageLimitResponse = (output, context) => {
     return {
-        usageLimit: output.usageLimit != null ? deserializeAws_json1_1UsageLimit(output.usageLimit, context) : undefined,
+        usageLimit: output.usageLimit != null ? de_UsageLimit(output.usageLimit, context) : undefined,
     };
 };
-const deserializeAws_json1_1UpdateWorkgroupResponse = (output, context) => {
+const de_UpdateWorkgroupResponse = (output, context) => {
     return {
-        workgroup: output.workgroup != null ? deserializeAws_json1_1Workgroup(output.workgroup, context) : undefined,
+        workgroup: output.workgroup != null ? de_Workgroup(output.workgroup, context) : undefined,
     };
 };
-const deserializeAws_json1_1UsageLimit = (output, context) => {
+const de_UsageLimit = (output, context) => {
     return {
         amount: __expectLong(output.amount),
         breachAction: __expectString(output.breachAction),
@@ -3057,89 +3049,83 @@ const deserializeAws_json1_1UsageLimit = (output, context) => {
         usageType: __expectString(output.usageType),
     };
 };
-const deserializeAws_json1_1UsageLimits = (output, context) => {
+const de_UsageLimits = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1UsageLimit(entry, context);
+        return de_UsageLimit(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ValidationException = (output, context) => {
+const de_ValidationException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1VpcEndpoint = (output, context) => {
+const de_VpcEndpoint = (output, context) => {
     return {
-        networkInterfaces: output.networkInterfaces != null
-            ? deserializeAws_json1_1NetworkInterfaceList(output.networkInterfaces, context)
-            : undefined,
+        networkInterfaces: output.networkInterfaces != null ? de_NetworkInterfaceList(output.networkInterfaces, context) : undefined,
         vpcEndpointId: __expectString(output.vpcEndpointId),
         vpcId: __expectString(output.vpcId),
     };
 };
-const deserializeAws_json1_1VpcEndpointList = (output, context) => {
+const de_VpcEndpointList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1VpcEndpoint(entry, context);
+        return de_VpcEndpoint(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1VpcSecurityGroupMembership = (output, context) => {
+const de_VpcSecurityGroupMembership = (output, context) => {
     return {
         status: __expectString(output.status),
         vpcSecurityGroupId: __expectString(output.vpcSecurityGroupId),
     };
 };
-const deserializeAws_json1_1VpcSecurityGroupMembershipList = (output, context) => {
+const de_VpcSecurityGroupMembershipList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1VpcSecurityGroupMembership(entry, context);
+        return de_VpcSecurityGroupMembership(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1Workgroup = (output, context) => {
+const de_Workgroup = (output, context) => {
     return {
         baseCapacity: __expectInt32(output.baseCapacity),
-        configParameters: output.configParameters != null
-            ? deserializeAws_json1_1ConfigParameterList(output.configParameters, context)
-            : undefined,
+        configParameters: output.configParameters != null ? de_ConfigParameterList(output.configParameters, context) : undefined,
         creationDate: output.creationDate != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.creationDate)) : undefined,
-        endpoint: output.endpoint != null ? deserializeAws_json1_1Endpoint(output.endpoint, context) : undefined,
+        endpoint: output.endpoint != null ? de_Endpoint(output.endpoint, context) : undefined,
         enhancedVpcRouting: __expectBoolean(output.enhancedVpcRouting),
         namespaceName: __expectString(output.namespaceName),
         port: __expectInt32(output.port),
         publiclyAccessible: __expectBoolean(output.publiclyAccessible),
-        securityGroupIds: output.securityGroupIds != null
-            ? deserializeAws_json1_1SecurityGroupIdList(output.securityGroupIds, context)
-            : undefined,
+        securityGroupIds: output.securityGroupIds != null ? de_SecurityGroupIdList(output.securityGroupIds, context) : undefined,
         status: __expectString(output.status),
-        subnetIds: output.subnetIds != null ? deserializeAws_json1_1SubnetIdList(output.subnetIds, context) : undefined,
+        subnetIds: output.subnetIds != null ? de_SubnetIdList(output.subnetIds, context) : undefined,
         workgroupArn: __expectString(output.workgroupArn),
         workgroupId: __expectString(output.workgroupId),
         workgroupName: __expectString(output.workgroupName),
     };
 };
-const deserializeAws_json1_1WorkgroupList = (output, context) => {
+const de_WorkgroupList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Workgroup(entry, context);
+        return de_Workgroup(entry, context);
     });
     return retVal;
 };