@aws-sdk/client-cleanrooms 3.306.0 → 3.309.0

package/dist-es/protocols/Aws_restJson1.js

@@ -2,7 +2,7 @@ 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, expectObject as __expectObject, expectString as __expectString, expectUnion as __expectUnion, limitedParseDouble as __limitedParseDouble, map as __map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { CleanRoomsServiceException as __BaseException } from "../models/CleanRoomsServiceException";
 import { AccessDeniedException, ConfiguredTableAnalysisRulePolicy, ConfiguredTableAnalysisRulePolicyV1, ConflictException, InternalServerException, ProtectedQueryOutputConfiguration, ResourceNotFoundException, ServiceQuotaExceededException, TableReference, ThrottlingException, ValidationException, } from "../models/models_0";
-export const serializeAws_restJson1BatchGetSchemaCommand = async (input, context) => {
+export const se_BatchGetSchemaCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -12,7 +12,7 @@ export const serializeAws_restJson1BatchGetSchemaCommand = async (input, context
     resolvedPath = __resolvedPath(resolvedPath, input, "collaborationIdentifier", () => input.collaborationIdentifier, "{collaborationIdentifier}", false);
     let body;
     body = JSON.stringify({
-        ...(input.names != null && { names: serializeAws_restJson1TableAliasList(input.names, context) }),
+        ...(input.names != null && { names: se_TableAliasList(input.names, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -24,7 +24,7 @@ export const serializeAws_restJson1BatchGetSchemaCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1CreateCollaborationCommand = async (input, context) => {
+export const se_CreateCollaborationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -34,16 +34,16 @@ export const serializeAws_restJson1CreateCollaborationCommand = async (input, co
     body = JSON.stringify({
         ...(input.creatorDisplayName != null && { creatorDisplayName: input.creatorDisplayName }),
         ...(input.creatorMemberAbilities != null && {
-            creatorMemberAbilities: serializeAws_restJson1MemberAbilities(input.creatorMemberAbilities, context),
+            creatorMemberAbilities: se_MemberAbilities(input.creatorMemberAbilities, context),
         }),
         ...(input.dataEncryptionMetadata != null && {
-            dataEncryptionMetadata: serializeAws_restJson1DataEncryptionMetadata(input.dataEncryptionMetadata, context),
+            dataEncryptionMetadata: se_DataEncryptionMetadata(input.dataEncryptionMetadata, context),
         }),
         ...(input.description != null && { description: input.description }),
-        ...(input.members != null && { members: serializeAws_restJson1MemberList(input.members, context) }),
+        ...(input.members != null && { members: se_MemberList(input.members, context) }),
         ...(input.name != null && { name: input.name }),
         ...(input.queryLogStatus != null && { queryLogStatus: input.queryLogStatus }),
-        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+        ...(input.tags != null && { tags: se_TagMap(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -55,7 +55,7 @@ export const serializeAws_restJson1CreateCollaborationCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1CreateConfiguredTableCommand = async (input, context) => {
+export const se_CreateConfiguredTableCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -63,16 +63,12 @@ export const serializeAws_restJson1CreateConfiguredTableCommand = async (input,
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/configuredTables";
     let body;
     body = JSON.stringify({
-        ...(input.allowedColumns != null && {
-            allowedColumns: serializeAws_restJson1AllowedColumnList(input.allowedColumns, context),
-        }),
+        ...(input.allowedColumns != null && { allowedColumns: se_AllowedColumnList(input.allowedColumns, context) }),
         ...(input.analysisMethod != null && { analysisMethod: input.analysisMethod }),
         ...(input.description != null && { description: input.description }),
         ...(input.name != null && { name: input.name }),
-        ...(input.tableReference != null && {
-            tableReference: serializeAws_restJson1TableReference(input.tableReference, context),
-        }),
-        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+        ...(input.tableReference != null && { tableReference: se_TableReference(input.tableReference, context) }),
+        ...(input.tags != null && { tags: se_TagMap(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -84,7 +80,7 @@ export const serializeAws_restJson1CreateConfiguredTableCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1CreateConfiguredTableAnalysisRuleCommand = async (input, context) => {
+export const se_CreateConfiguredTableAnalysisRuleCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -95,7 +91,7 @@ export const serializeAws_restJson1CreateConfiguredTableAnalysisRuleCommand = as
     let body;
     body = JSON.stringify({
         ...(input.analysisRulePolicy != null && {
-            analysisRulePolicy: serializeAws_restJson1ConfiguredTableAnalysisRulePolicy(input.analysisRulePolicy, context),
+            analysisRulePolicy: se_ConfiguredTableAnalysisRulePolicy(input.analysisRulePolicy, context),
         }),
         ...(input.analysisRuleType != null && { analysisRuleType: input.analysisRuleType }),
     });
@@ -109,7 +105,7 @@ export const serializeAws_restJson1CreateConfiguredTableAnalysisRuleCommand = as
         body,
     });
 };
-export const serializeAws_restJson1CreateConfiguredTableAssociationCommand = async (input, context) => {
+export const se_CreateConfiguredTableAssociationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -123,7 +119,7 @@ export const serializeAws_restJson1CreateConfiguredTableAssociationCommand = asy
         ...(input.description != null && { description: input.description }),
         ...(input.name != null && { name: input.name }),
         ...(input.roleArn != null && { roleArn: input.roleArn }),
-        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+        ...(input.tags != null && { tags: se_TagMap(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -135,7 +131,7 @@ export const serializeAws_restJson1CreateConfiguredTableAssociationCommand = asy
         body,
     });
 };
-export const serializeAws_restJson1CreateMembershipCommand = async (input, context) => {
+export const se_CreateMembershipCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -145,7 +141,7 @@ export const serializeAws_restJson1CreateMembershipCommand = async (input, conte
     body = JSON.stringify({
         ...(input.collaborationIdentifier != null && { collaborationIdentifier: input.collaborationIdentifier }),
         ...(input.queryLogStatus != null && { queryLogStatus: input.queryLogStatus }),
-        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+        ...(input.tags != null && { tags: se_TagMap(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -157,7 +153,7 @@ export const serializeAws_restJson1CreateMembershipCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1DeleteCollaborationCommand = async (input, context) => {
+export const se_DeleteCollaborationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/collaborations/{collaborationIdentifier}";
@@ -173,7 +169,7 @@ export const serializeAws_restJson1DeleteCollaborationCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1DeleteConfiguredTableCommand = async (input, context) => {
+export const se_DeleteConfiguredTableCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -190,7 +186,7 @@ export const serializeAws_restJson1DeleteConfiguredTableCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1DeleteConfiguredTableAnalysisRuleCommand = async (input, context) => {
+export const se_DeleteConfiguredTableAnalysisRuleCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -208,7 +204,7 @@ export const serializeAws_restJson1DeleteConfiguredTableAnalysisRuleCommand = as
         body,
     });
 };
-export const serializeAws_restJson1DeleteConfiguredTableAssociationCommand = async (input, context) => {
+export const se_DeleteConfiguredTableAssociationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -226,7 +222,7 @@ export const serializeAws_restJson1DeleteConfiguredTableAssociationCommand = asy
         body,
     });
 };
-export const serializeAws_restJson1DeleteMemberCommand = async (input, context) => {
+export const se_DeleteMemberCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -244,7 +240,7 @@ export const serializeAws_restJson1DeleteMemberCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1DeleteMembershipCommand = async (input, context) => {
+export const se_DeleteMembershipCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/memberships/{membershipIdentifier}";
@@ -260,7 +256,7 @@ export const serializeAws_restJson1DeleteMembershipCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1GetCollaborationCommand = async (input, context) => {
+export const se_GetCollaborationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/collaborations/{collaborationIdentifier}";
@@ -276,7 +272,7 @@ export const serializeAws_restJson1GetCollaborationCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1GetConfiguredTableCommand = async (input, context) => {
+export const se_GetConfiguredTableCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -293,7 +289,7 @@ export const serializeAws_restJson1GetConfiguredTableCommand = async (input, con
         body,
     });
 };
-export const serializeAws_restJson1GetConfiguredTableAnalysisRuleCommand = async (input, context) => {
+export const se_GetConfiguredTableAnalysisRuleCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -311,7 +307,7 @@ export const serializeAws_restJson1GetConfiguredTableAnalysisRuleCommand = async
         body,
     });
 };
-export const serializeAws_restJson1GetConfiguredTableAssociationCommand = async (input, context) => {
+export const se_GetConfiguredTableAssociationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -329,7 +325,7 @@ export const serializeAws_restJson1GetConfiguredTableAssociationCommand = async
         body,
     });
 };
-export const serializeAws_restJson1GetMembershipCommand = async (input, context) => {
+export const se_GetMembershipCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/memberships/{membershipIdentifier}";
@@ -345,7 +341,7 @@ export const serializeAws_restJson1GetMembershipCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1GetProtectedQueryCommand = async (input, context) => {
+export const se_GetProtectedQueryCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -363,7 +359,7 @@ export const serializeAws_restJson1GetProtectedQueryCommand = async (input, cont
         body,
     });
 };
-export const serializeAws_restJson1GetSchemaCommand = async (input, context) => {
+export const se_GetSchemaCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -381,7 +377,7 @@ export const serializeAws_restJson1GetSchemaCommand = async (input, context) =>
         body,
     });
 };
-export const serializeAws_restJson1GetSchemaAnalysisRuleCommand = async (input, context) => {
+export const se_GetSchemaAnalysisRuleCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -400,7 +396,7 @@ export const serializeAws_restJson1GetSchemaAnalysisRuleCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1ListCollaborationsCommand = async (input, context) => {
+export const se_ListCollaborationsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/collaborations";
@@ -421,7 +417,7 @@ export const serializeAws_restJson1ListCollaborationsCommand = async (input, con
         body,
     });
 };
-export const serializeAws_restJson1ListConfiguredTableAssociationsCommand = async (input, context) => {
+export const se_ListConfiguredTableAssociationsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -443,7 +439,7 @@ export const serializeAws_restJson1ListConfiguredTableAssociationsCommand = asyn
         body,
     });
 };
-export const serializeAws_restJson1ListConfiguredTablesCommand = async (input, context) => {
+export const se_ListConfiguredTablesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/configuredTables";
@@ -463,7 +459,7 @@ export const serializeAws_restJson1ListConfiguredTablesCommand = async (input, c
         body,
     });
 };
-export const serializeAws_restJson1ListMembersCommand = async (input, context) => {
+export const se_ListMembersCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -485,7 +481,7 @@ export const serializeAws_restJson1ListMembersCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1ListMembershipsCommand = async (input, context) => {
+export const se_ListMembershipsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/memberships";
@@ -506,7 +502,7 @@ export const serializeAws_restJson1ListMembershipsCommand = async (input, contex
         body,
     });
 };
-export const serializeAws_restJson1ListProtectedQueriesCommand = async (input, context) => {
+export const se_ListProtectedQueriesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -529,7 +525,7 @@ export const serializeAws_restJson1ListProtectedQueriesCommand = async (input, c
         body,
     });
 };
-export const serializeAws_restJson1ListSchemasCommand = async (input, context) => {
+export const se_ListSchemasCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -552,7 +548,7 @@ export const serializeAws_restJson1ListSchemasCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1ListTagsForResourceCommand = async (input, context) => {
+export const se_ListTagsForResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
@@ -568,7 +564,7 @@ export const serializeAws_restJson1ListTagsForResourceCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1StartProtectedQueryCommand = async (input, context) => {
+export const se_StartProtectedQueryCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -579,11 +575,9 @@ export const serializeAws_restJson1StartProtectedQueryCommand = async (input, co
     let body;
     body = JSON.stringify({
         ...(input.resultConfiguration != null && {
-            resultConfiguration: serializeAws_restJson1ProtectedQueryResultConfiguration(input.resultConfiguration, context),
-        }),
-        ...(input.sqlParameters != null && {
-            sqlParameters: serializeAws_restJson1ProtectedQuerySQLParameters(input.sqlParameters, context),
+            resultConfiguration: se_ProtectedQueryResultConfiguration(input.resultConfiguration, context),
         }),
+        ...(input.sqlParameters != null && { sqlParameters: se_ProtectedQuerySQLParameters(input.sqlParameters, context) }),
         ...(input.type != null && { type: input.type }),
     });
     return new __HttpRequest({
@@ -596,7 +590,7 @@ export const serializeAws_restJson1StartProtectedQueryCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1TagResourceCommand = async (input, context) => {
+export const se_TagResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -605,7 +599,7 @@ export const serializeAws_restJson1TagResourceCommand = async (input, context) =
     resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
     let body;
     body = JSON.stringify({
-        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+        ...(input.tags != null && { tags: se_TagMap(input.tags, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -617,7 +611,7 @@ export const serializeAws_restJson1TagResourceCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1UntagResourceCommand = async (input, context) => {
+export const se_UntagResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
@@ -640,7 +634,7 @@ export const serializeAws_restJson1UntagResourceCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1UpdateCollaborationCommand = async (input, context) => {
+export const se_UpdateCollaborationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -662,7 +656,7 @@ export const serializeAws_restJson1UpdateCollaborationCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1UpdateConfiguredTableCommand = async (input, context) => {
+export const se_UpdateConfiguredTableCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -685,7 +679,7 @@ export const serializeAws_restJson1UpdateConfiguredTableCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1UpdateConfiguredTableAnalysisRuleCommand = async (input, context) => {
+export const se_UpdateConfiguredTableAnalysisRuleCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -697,7 +691,7 @@ export const serializeAws_restJson1UpdateConfiguredTableAnalysisRuleCommand = as
     let body;
     body = JSON.stringify({
         ...(input.analysisRulePolicy != null && {
-            analysisRulePolicy: serializeAws_restJson1ConfiguredTableAnalysisRulePolicy(input.analysisRulePolicy, context),
+            analysisRulePolicy: se_ConfiguredTableAnalysisRulePolicy(input.analysisRulePolicy, context),
         }),
     });
     return new __HttpRequest({
@@ -710,7 +704,7 @@ export const serializeAws_restJson1UpdateConfiguredTableAnalysisRuleCommand = as
         body,
     });
 };
-export const serializeAws_restJson1UpdateConfiguredTableAssociationCommand = async (input, context) => {
+export const se_UpdateConfiguredTableAssociationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -734,7 +728,7 @@ export const serializeAws_restJson1UpdateConfiguredTableAssociationCommand = asy
         body,
     });
 };
-export const serializeAws_restJson1UpdateMembershipCommand = async (input, context) => {
+export const se_UpdateMembershipCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -755,7 +749,7 @@ export const serializeAws_restJson1UpdateMembershipCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1UpdateProtectedQueryCommand = async (input, context) => {
+export const se_UpdateProtectedQueryCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -778,23 +772,23 @@ export const serializeAws_restJson1UpdateProtectedQueryCommand = async (input, c
         body,
     });
 };
-export const deserializeAws_restJson1BatchGetSchemaCommand = async (output, context) => {
+export const de_BatchGetSchemaCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1BatchGetSchemaCommandError(output, context);
+        return de_BatchGetSchemaCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.errors != null) {
-        contents.errors = deserializeAws_restJson1BatchGetSchemaErrorList(data.errors, context);
+        contents.errors = de_BatchGetSchemaErrorList(data.errors, context);
     }
     if (data.schemas != null) {
-        contents.schemas = deserializeAws_restJson1SchemaList(data.schemas, context);
+        contents.schemas = de_SchemaList(data.schemas, context);
     }
     return contents;
 };
-const deserializeAws_restJson1BatchGetSchemaCommandError = async (output, context) => {
+const de_BatchGetSchemaCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -803,19 +797,19 @@ const deserializeAws_restJson1BatchGetSchemaCommandError = async (output, contex
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -826,20 +820,20 @@ const deserializeAws_restJson1BatchGetSchemaCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1CreateCollaborationCommand = async (output, context) => {
+export const de_CreateCollaborationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateCollaborationCommandError(output, context);
+        return de_CreateCollaborationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.collaboration != null) {
-        contents.collaboration = deserializeAws_restJson1Collaboration(data.collaboration, context);
+        contents.collaboration = de_Collaboration(data.collaboration, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateCollaborationCommandError = async (output, context) => {
+const de_CreateCollaborationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -848,19 +842,19 @@ const deserializeAws_restJson1CreateCollaborationCommandError = async (output, c
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ServiceQuotaExceededException":
         case "com.amazonaws.cleanrooms#ServiceQuotaExceededException":
-            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -871,20 +865,20 @@ const deserializeAws_restJson1CreateCollaborationCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1CreateConfiguredTableCommand = async (output, context) => {
+export const de_CreateConfiguredTableCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateConfiguredTableCommandError(output, context);
+        return de_CreateConfiguredTableCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.configuredTable != null) {
-        contents.configuredTable = deserializeAws_restJson1ConfiguredTable(data.configuredTable, context);
+        contents.configuredTable = de_ConfiguredTable(data.configuredTable, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateConfiguredTableCommandError = async (output, context) => {
+const de_CreateConfiguredTableCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -893,25 +887,25 @@ const deserializeAws_restJson1CreateConfiguredTableCommandError = async (output,
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.cleanrooms#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceQuotaExceededException":
         case "com.amazonaws.cleanrooms#ServiceQuotaExceededException":
-            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -922,20 +916,20 @@ const deserializeAws_restJson1CreateConfiguredTableCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1CreateConfiguredTableAnalysisRuleCommand = async (output, context) => {
+export const de_CreateConfiguredTableAnalysisRuleCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateConfiguredTableAnalysisRuleCommandError(output, context);
+        return de_CreateConfiguredTableAnalysisRuleCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.analysisRule != null) {
-        contents.analysisRule = deserializeAws_restJson1ConfiguredTableAnalysisRule(data.analysisRule, context);
+        contents.analysisRule = de_ConfiguredTableAnalysisRule(data.analysisRule, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateConfiguredTableAnalysisRuleCommandError = async (output, context) => {
+const de_CreateConfiguredTableAnalysisRuleCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -944,22 +938,22 @@ const deserializeAws_restJson1CreateConfiguredTableAnalysisRuleCommandError = as
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.cleanrooms#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -970,20 +964,20 @@ const deserializeAws_restJson1CreateConfiguredTableAnalysisRuleCommandError = as
             });
     }
 };
-export const deserializeAws_restJson1CreateConfiguredTableAssociationCommand = async (output, context) => {
+export const de_CreateConfiguredTableAssociationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateConfiguredTableAssociationCommandError(output, context);
+        return de_CreateConfiguredTableAssociationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.configuredTableAssociation != null) {
-        contents.configuredTableAssociation = deserializeAws_restJson1ConfiguredTableAssociation(data.configuredTableAssociation, context);
+        contents.configuredTableAssociation = de_ConfiguredTableAssociation(data.configuredTableAssociation, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateConfiguredTableAssociationCommandError = async (output, context) => {
+const de_CreateConfiguredTableAssociationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -992,25 +986,25 @@ const deserializeAws_restJson1CreateConfiguredTableAssociationCommandError = asy
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.cleanrooms#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceQuotaExceededException":
         case "com.amazonaws.cleanrooms#ServiceQuotaExceededException":
-            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1021,20 +1015,20 @@ const deserializeAws_restJson1CreateConfiguredTableAssociationCommandError = asy
             });
     }
 };
-export const deserializeAws_restJson1CreateMembershipCommand = async (output, context) => {
+export const de_CreateMembershipCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateMembershipCommandError(output, context);
+        return de_CreateMembershipCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.membership != null) {
-        contents.membership = deserializeAws_restJson1Membership(data.membership, context);
+        contents.membership = de_Membership(data.membership, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateMembershipCommandError = async (output, context) => {
+const de_CreateMembershipCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1043,25 +1037,25 @@ const deserializeAws_restJson1CreateMembershipCommandError = async (output, cont
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.cleanrooms#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceQuotaExceededException":
         case "com.amazonaws.cleanrooms#ServiceQuotaExceededException":
-            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1072,9 +1066,9 @@ const deserializeAws_restJson1CreateMembershipCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1DeleteCollaborationCommand = async (output, context) => {
+export const de_DeleteCollaborationCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteCollaborationCommandError(output, context);
+        return de_DeleteCollaborationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1082,7 +1076,7 @@ export const deserializeAws_restJson1DeleteCollaborationCommand = async (output,
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteCollaborationCommandError = async (output, context) => {
+const de_DeleteCollaborationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1091,16 +1085,16 @@ const deserializeAws_restJson1DeleteCollaborationCommandError = async (output, c
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1111,9 +1105,9 @@ const deserializeAws_restJson1DeleteCollaborationCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1DeleteConfiguredTableCommand = async (output, context) => {
+export const de_DeleteConfiguredTableCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteConfiguredTableCommandError(output, context);
+        return de_DeleteConfiguredTableCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1121,7 +1115,7 @@ export const deserializeAws_restJson1DeleteConfiguredTableCommand = async (outpu
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteConfiguredTableCommandError = async (output, context) => {
+const de_DeleteConfiguredTableCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1130,22 +1124,22 @@ const deserializeAws_restJson1DeleteConfiguredTableCommandError = async (output,
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.cleanrooms#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1156,9 +1150,9 @@ const deserializeAws_restJson1DeleteConfiguredTableCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1DeleteConfiguredTableAnalysisRuleCommand = async (output, context) => {
+export const de_DeleteConfiguredTableAnalysisRuleCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteConfiguredTableAnalysisRuleCommandError(output, context);
+        return de_DeleteConfiguredTableAnalysisRuleCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1166,7 +1160,7 @@ export const deserializeAws_restJson1DeleteConfiguredTableAnalysisRuleCommand =
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteConfiguredTableAnalysisRuleCommandError = async (output, context) => {
+const de_DeleteConfiguredTableAnalysisRuleCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1175,22 +1169,22 @@ const deserializeAws_restJson1DeleteConfiguredTableAnalysisRuleCommandError = as
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.cleanrooms#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1201,9 +1195,9 @@ const deserializeAws_restJson1DeleteConfiguredTableAnalysisRuleCommandError = as
             });
     }
 };
-export const deserializeAws_restJson1DeleteConfiguredTableAssociationCommand = async (output, context) => {
+export const de_DeleteConfiguredTableAssociationCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteConfiguredTableAssociationCommandError(output, context);
+        return de_DeleteConfiguredTableAssociationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1211,7 +1205,7 @@ export const deserializeAws_restJson1DeleteConfiguredTableAssociationCommand = a
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteConfiguredTableAssociationCommandError = async (output, context) => {
+const de_DeleteConfiguredTableAssociationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1220,22 +1214,22 @@ const deserializeAws_restJson1DeleteConfiguredTableAssociationCommandError = asy
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.cleanrooms#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1246,9 +1240,9 @@ const deserializeAws_restJson1DeleteConfiguredTableAssociationCommandError = asy
             });
     }
 };
-export const deserializeAws_restJson1DeleteMemberCommand = async (output, context) => {
+export const de_DeleteMemberCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteMemberCommandError(output, context);
+        return de_DeleteMemberCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1256,7 +1250,7 @@ export const deserializeAws_restJson1DeleteMemberCommand = async (output, contex
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteMemberCommandError = async (output, context) => {
+const de_DeleteMemberCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1265,22 +1259,22 @@ const deserializeAws_restJson1DeleteMemberCommandError = async (output, context)
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.cleanrooms#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1291,9 +1285,9 @@ const deserializeAws_restJson1DeleteMemberCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1DeleteMembershipCommand = async (output, context) => {
+export const de_DeleteMembershipCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteMembershipCommandError(output, context);
+        return de_DeleteMembershipCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1301,7 +1295,7 @@ export const deserializeAws_restJson1DeleteMembershipCommand = async (output, co
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteMembershipCommandError = async (output, context) => {
+const de_DeleteMembershipCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1310,22 +1304,22 @@ const deserializeAws_restJson1DeleteMembershipCommandError = async (output, cont
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.cleanrooms#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1336,20 +1330,20 @@ const deserializeAws_restJson1DeleteMembershipCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1GetCollaborationCommand = async (output, context) => {
+export const de_GetCollaborationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetCollaborationCommandError(output, context);
+        return de_GetCollaborationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.collaboration != null) {
-        contents.collaboration = deserializeAws_restJson1Collaboration(data.collaboration, context);
+        contents.collaboration = de_Collaboration(data.collaboration, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetCollaborationCommandError = async (output, context) => {
+const de_GetCollaborationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1358,16 +1352,16 @@ const deserializeAws_restJson1GetCollaborationCommandError = async (output, cont
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1378,20 +1372,20 @@ const deserializeAws_restJson1GetCollaborationCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1GetConfiguredTableCommand = async (output, context) => {
+export const de_GetConfiguredTableCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetConfiguredTableCommandError(output, context);
+        return de_GetConfiguredTableCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.configuredTable != null) {
-        contents.configuredTable = deserializeAws_restJson1ConfiguredTable(data.configuredTable, context);
+        contents.configuredTable = de_ConfiguredTable(data.configuredTable, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetConfiguredTableCommandError = async (output, context) => {
+const de_GetConfiguredTableCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1400,19 +1394,19 @@ const deserializeAws_restJson1GetConfiguredTableCommandError = async (output, co
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1423,20 +1417,20 @@ const deserializeAws_restJson1GetConfiguredTableCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_restJson1GetConfiguredTableAnalysisRuleCommand = async (output, context) => {
+export const de_GetConfiguredTableAnalysisRuleCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetConfiguredTableAnalysisRuleCommandError(output, context);
+        return de_GetConfiguredTableAnalysisRuleCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.analysisRule != null) {
-        contents.analysisRule = deserializeAws_restJson1ConfiguredTableAnalysisRule(data.analysisRule, context);
+        contents.analysisRule = de_ConfiguredTableAnalysisRule(data.analysisRule, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetConfiguredTableAnalysisRuleCommandError = async (output, context) => {
+const de_GetConfiguredTableAnalysisRuleCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1445,19 +1439,19 @@ const deserializeAws_restJson1GetConfiguredTableAnalysisRuleCommandError = async
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1468,20 +1462,20 @@ const deserializeAws_restJson1GetConfiguredTableAnalysisRuleCommandError = async
             });
     }
 };
-export const deserializeAws_restJson1GetConfiguredTableAssociationCommand = async (output, context) => {
+export const de_GetConfiguredTableAssociationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetConfiguredTableAssociationCommandError(output, context);
+        return de_GetConfiguredTableAssociationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.configuredTableAssociation != null) {
-        contents.configuredTableAssociation = deserializeAws_restJson1ConfiguredTableAssociation(data.configuredTableAssociation, context);
+        contents.configuredTableAssociation = de_ConfiguredTableAssociation(data.configuredTableAssociation, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetConfiguredTableAssociationCommandError = async (output, context) => {
+const de_GetConfiguredTableAssociationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1490,19 +1484,19 @@ const deserializeAws_restJson1GetConfiguredTableAssociationCommandError = async
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1513,20 +1507,20 @@ const deserializeAws_restJson1GetConfiguredTableAssociationCommandError = async
             });
     }
 };
-export const deserializeAws_restJson1GetMembershipCommand = async (output, context) => {
+export const de_GetMembershipCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetMembershipCommandError(output, context);
+        return de_GetMembershipCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.membership != null) {
-        contents.membership = deserializeAws_restJson1Membership(data.membership, context);
+        contents.membership = de_Membership(data.membership, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetMembershipCommandError = async (output, context) => {
+const de_GetMembershipCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1535,19 +1529,19 @@ const deserializeAws_restJson1GetMembershipCommandError = async (output, context
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1558,20 +1552,20 @@ const deserializeAws_restJson1GetMembershipCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1GetProtectedQueryCommand = async (output, context) => {
+export const de_GetProtectedQueryCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetProtectedQueryCommandError(output, context);
+        return de_GetProtectedQueryCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.protectedQuery != null) {
-        contents.protectedQuery = deserializeAws_restJson1ProtectedQuery(data.protectedQuery, context);
+        contents.protectedQuery = de_ProtectedQuery(data.protectedQuery, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetProtectedQueryCommandError = async (output, context) => {
+const de_GetProtectedQueryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1580,19 +1574,19 @@ const deserializeAws_restJson1GetProtectedQueryCommandError = async (output, con
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1603,20 +1597,20 @@ const deserializeAws_restJson1GetProtectedQueryCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1GetSchemaCommand = async (output, context) => {
+export const de_GetSchemaCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetSchemaCommandError(output, context);
+        return de_GetSchemaCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.schema != null) {
-        contents.schema = deserializeAws_restJson1Schema(data.schema, context);
+        contents.schema = de_Schema(data.schema, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetSchemaCommandError = async (output, context) => {
+const de_GetSchemaCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1625,19 +1619,19 @@ const deserializeAws_restJson1GetSchemaCommandError = async (output, context) =>
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1648,20 +1642,20 @@ const deserializeAws_restJson1GetSchemaCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_restJson1GetSchemaAnalysisRuleCommand = async (output, context) => {
+export const de_GetSchemaAnalysisRuleCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetSchemaAnalysisRuleCommandError(output, context);
+        return de_GetSchemaAnalysisRuleCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.analysisRule != null) {
-        contents.analysisRule = deserializeAws_restJson1AnalysisRule(data.analysisRule, context);
+        contents.analysisRule = de_AnalysisRule(data.analysisRule, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetSchemaAnalysisRuleCommandError = async (output, context) => {
+const de_GetSchemaAnalysisRuleCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1670,19 +1664,19 @@ const deserializeAws_restJson1GetSchemaAnalysisRuleCommandError = async (output,
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1693,23 +1687,23 @@ const deserializeAws_restJson1GetSchemaAnalysisRuleCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1ListCollaborationsCommand = async (output, context) => {
+export const de_ListCollaborationsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListCollaborationsCommandError(output, context);
+        return de_ListCollaborationsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.collaborationList != null) {
-        contents.collaborationList = deserializeAws_restJson1CollaborationSummaryList(data.collaborationList, context);
+        contents.collaborationList = de_CollaborationSummaryList(data.collaborationList, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListCollaborationsCommandError = async (output, context) => {
+const de_ListCollaborationsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1718,16 +1712,16 @@ const deserializeAws_restJson1ListCollaborationsCommandError = async (output, co
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1738,23 +1732,23 @@ const deserializeAws_restJson1ListCollaborationsCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_restJson1ListConfiguredTableAssociationsCommand = async (output, context) => {
+export const de_ListConfiguredTableAssociationsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListConfiguredTableAssociationsCommandError(output, context);
+        return de_ListConfiguredTableAssociationsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.configuredTableAssociationSummaries != null) {
-        contents.configuredTableAssociationSummaries = deserializeAws_restJson1ConfiguredTableAssociationSummaryList(data.configuredTableAssociationSummaries, context);
+        contents.configuredTableAssociationSummaries = de_ConfiguredTableAssociationSummaryList(data.configuredTableAssociationSummaries, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListConfiguredTableAssociationsCommandError = async (output, context) => {
+const de_ListConfiguredTableAssociationsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1763,19 +1757,19 @@ const deserializeAws_restJson1ListConfiguredTableAssociationsCommandError = asyn
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1786,23 +1780,23 @@ const deserializeAws_restJson1ListConfiguredTableAssociationsCommandError = asyn
             });
     }
 };
-export const deserializeAws_restJson1ListConfiguredTablesCommand = async (output, context) => {
+export const de_ListConfiguredTablesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListConfiguredTablesCommandError(output, context);
+        return de_ListConfiguredTablesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.configuredTableSummaries != null) {
-        contents.configuredTableSummaries = deserializeAws_restJson1ConfiguredTableSummaryList(data.configuredTableSummaries, context);
+        contents.configuredTableSummaries = de_ConfiguredTableSummaryList(data.configuredTableSummaries, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListConfiguredTablesCommandError = async (output, context) => {
+const de_ListConfiguredTablesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1811,16 +1805,16 @@ const deserializeAws_restJson1ListConfiguredTablesCommandError = async (output,
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1831,23 +1825,23 @@ const deserializeAws_restJson1ListConfiguredTablesCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1ListMembersCommand = async (output, context) => {
+export const de_ListMembersCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListMembersCommandError(output, context);
+        return de_ListMembersCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.memberSummaries != null) {
-        contents.memberSummaries = deserializeAws_restJson1MemberSummaryList(data.memberSummaries, context);
+        contents.memberSummaries = de_MemberSummaryList(data.memberSummaries, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListMembersCommandError = async (output, context) => {
+const de_ListMembersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1856,19 +1850,19 @@ const deserializeAws_restJson1ListMembersCommandError = async (output, context)
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1879,23 +1873,23 @@ const deserializeAws_restJson1ListMembersCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1ListMembershipsCommand = async (output, context) => {
+export const de_ListMembershipsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListMembershipsCommandError(output, context);
+        return de_ListMembershipsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.membershipSummaries != null) {
-        contents.membershipSummaries = deserializeAws_restJson1MembershipSummaryList(data.membershipSummaries, context);
+        contents.membershipSummaries = de_MembershipSummaryList(data.membershipSummaries, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListMembershipsCommandError = async (output, context) => {
+const de_ListMembershipsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1904,16 +1898,16 @@ const deserializeAws_restJson1ListMembershipsCommandError = async (output, conte
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1924,9 +1918,9 @@ const deserializeAws_restJson1ListMembershipsCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_restJson1ListProtectedQueriesCommand = async (output, context) => {
+export const de_ListProtectedQueriesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListProtectedQueriesCommandError(output, context);
+        return de_ListProtectedQueriesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1936,11 +1930,11 @@ export const deserializeAws_restJson1ListProtectedQueriesCommand = async (output
         contents.nextToken = __expectString(data.nextToken);
     }
     if (data.protectedQueries != null) {
-        contents.protectedQueries = deserializeAws_restJson1ProtectedQuerySummaryList(data.protectedQueries, context);
+        contents.protectedQueries = de_ProtectedQuerySummaryList(data.protectedQueries, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListProtectedQueriesCommandError = async (output, context) => {
+const de_ListProtectedQueriesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1949,19 +1943,19 @@ const deserializeAws_restJson1ListProtectedQueriesCommandError = async (output,
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1972,9 +1966,9 @@ const deserializeAws_restJson1ListProtectedQueriesCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1ListSchemasCommand = async (output, context) => {
+export const de_ListSchemasCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListSchemasCommandError(output, context);
+        return de_ListSchemasCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1984,11 +1978,11 @@ export const deserializeAws_restJson1ListSchemasCommand = async (output, context
         contents.nextToken = __expectString(data.nextToken);
     }
     if (data.schemaSummaries != null) {
-        contents.schemaSummaries = deserializeAws_restJson1SchemaSummaryList(data.schemaSummaries, context);
+        contents.schemaSummaries = de_SchemaSummaryList(data.schemaSummaries, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListSchemasCommandError = async (output, context) => {
+const de_ListSchemasCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1997,19 +1991,19 @@ const deserializeAws_restJson1ListSchemasCommandError = async (output, context)
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2020,20 +2014,20 @@ const deserializeAws_restJson1ListSchemasCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
+export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListTagsForResourceCommandError(output, context);
+        return de_ListTagsForResourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.tags != null) {
-        contents.tags = deserializeAws_restJson1TagMap(data.tags, context);
+        contents.tags = de_TagMap(data.tags, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, context) => {
+const de_ListTagsForResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2042,10 +2036,10 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
     switch (errorCode) {
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2056,20 +2050,20 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1StartProtectedQueryCommand = async (output, context) => {
+export const de_StartProtectedQueryCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1StartProtectedQueryCommandError(output, context);
+        return de_StartProtectedQueryCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.protectedQuery != null) {
-        contents.protectedQuery = deserializeAws_restJson1ProtectedQuery(data.protectedQuery, context);
+        contents.protectedQuery = de_ProtectedQuery(data.protectedQuery, context);
     }
     return contents;
 };
-const deserializeAws_restJson1StartProtectedQueryCommandError = async (output, context) => {
+const de_StartProtectedQueryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2078,22 +2072,22 @@ const deserializeAws_restJson1StartProtectedQueryCommandError = async (output, c
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceQuotaExceededException":
         case "com.amazonaws.cleanrooms#ServiceQuotaExceededException":
-            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2104,9 +2098,9 @@ const deserializeAws_restJson1StartProtectedQueryCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
+export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1TagResourceCommandError(output, context);
+        return de_TagResourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2114,7 +2108,7 @@ export const deserializeAws_restJson1TagResourceCommand = async (output, context
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1TagResourceCommandError = async (output, context) => {
+const de_TagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2123,10 +2117,10 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
     switch (errorCode) {
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2137,9 +2131,9 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
+export const de_UntagResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UntagResourceCommandError(output, context);
+        return de_UntagResourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2147,7 +2141,7 @@ export const deserializeAws_restJson1UntagResourceCommand = async (output, conte
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1UntagResourceCommandError = async (output, context) => {
+const de_UntagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2156,10 +2150,10 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
     switch (errorCode) {
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2170,20 +2164,20 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1UpdateCollaborationCommand = async (output, context) => {
+export const de_UpdateCollaborationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateCollaborationCommandError(output, context);
+        return de_UpdateCollaborationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.collaboration != null) {
-        contents.collaboration = deserializeAws_restJson1Collaboration(data.collaboration, context);
+        contents.collaboration = de_Collaboration(data.collaboration, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateCollaborationCommandError = async (output, context) => {
+const de_UpdateCollaborationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2192,16 +2186,16 @@ const deserializeAws_restJson1UpdateCollaborationCommandError = async (output, c
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2212,20 +2206,20 @@ const deserializeAws_restJson1UpdateCollaborationCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1UpdateConfiguredTableCommand = async (output, context) => {
+export const de_UpdateConfiguredTableCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateConfiguredTableCommandError(output, context);
+        return de_UpdateConfiguredTableCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.configuredTable != null) {
-        contents.configuredTable = deserializeAws_restJson1ConfiguredTable(data.configuredTable, context);
+        contents.configuredTable = de_ConfiguredTable(data.configuredTable, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateConfiguredTableCommandError = async (output, context) => {
+const de_UpdateConfiguredTableCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2234,22 +2228,22 @@ const deserializeAws_restJson1UpdateConfiguredTableCommandError = async (output,
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.cleanrooms#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2260,20 +2254,20 @@ const deserializeAws_restJson1UpdateConfiguredTableCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1UpdateConfiguredTableAnalysisRuleCommand = async (output, context) => {
+export const de_UpdateConfiguredTableAnalysisRuleCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateConfiguredTableAnalysisRuleCommandError(output, context);
+        return de_UpdateConfiguredTableAnalysisRuleCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.analysisRule != null) {
-        contents.analysisRule = deserializeAws_restJson1ConfiguredTableAnalysisRule(data.analysisRule, context);
+        contents.analysisRule = de_ConfiguredTableAnalysisRule(data.analysisRule, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateConfiguredTableAnalysisRuleCommandError = async (output, context) => {
+const de_UpdateConfiguredTableAnalysisRuleCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2282,22 +2276,22 @@ const deserializeAws_restJson1UpdateConfiguredTableAnalysisRuleCommandError = as
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.cleanrooms#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2308,20 +2302,20 @@ const deserializeAws_restJson1UpdateConfiguredTableAnalysisRuleCommandError = as
             });
     }
 };
-export const deserializeAws_restJson1UpdateConfiguredTableAssociationCommand = async (output, context) => {
+export const de_UpdateConfiguredTableAssociationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateConfiguredTableAssociationCommandError(output, context);
+        return de_UpdateConfiguredTableAssociationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.configuredTableAssociation != null) {
-        contents.configuredTableAssociation = deserializeAws_restJson1ConfiguredTableAssociation(data.configuredTableAssociation, context);
+        contents.configuredTableAssociation = de_ConfiguredTableAssociation(data.configuredTableAssociation, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateConfiguredTableAssociationCommandError = async (output, context) => {
+const de_UpdateConfiguredTableAssociationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2330,22 +2324,22 @@ const deserializeAws_restJson1UpdateConfiguredTableAssociationCommandError = asy
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.cleanrooms#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2356,20 +2350,20 @@ const deserializeAws_restJson1UpdateConfiguredTableAssociationCommandError = asy
             });
     }
 };
-export const deserializeAws_restJson1UpdateMembershipCommand = async (output, context) => {
+export const de_UpdateMembershipCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateMembershipCommandError(output, context);
+        return de_UpdateMembershipCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.membership != null) {
-        contents.membership = deserializeAws_restJson1Membership(data.membership, context);
+        contents.membership = de_Membership(data.membership, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateMembershipCommandError = async (output, context) => {
+const de_UpdateMembershipCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2378,22 +2372,22 @@ const deserializeAws_restJson1UpdateMembershipCommandError = async (output, cont
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.cleanrooms#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2404,20 +2398,20 @@ const deserializeAws_restJson1UpdateMembershipCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1UpdateProtectedQueryCommand = async (output, context) => {
+export const de_UpdateProtectedQueryCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateProtectedQueryCommandError(output, context);
+        return de_UpdateProtectedQueryCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.protectedQuery != null) {
-        contents.protectedQuery = deserializeAws_restJson1ProtectedQuery(data.protectedQuery, context);
+        contents.protectedQuery = de_ProtectedQuery(data.protectedQuery, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateProtectedQueryCommandError = async (output, context) => {
+const de_UpdateProtectedQueryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2426,22 +2420,22 @@ const deserializeAws_restJson1UpdateProtectedQueryCommandError = async (output,
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.cleanrooms#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.cleanrooms#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.cleanrooms#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.cleanrooms#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.cleanrooms#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.cleanrooms#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2453,7 +2447,7 @@ const deserializeAws_restJson1UpdateProtectedQueryCommandError = async (output,
     }
 };
 const map = __map;
-const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
+const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2468,7 +2462,7 @@ const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutpu
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
+const de_ConflictExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2489,7 +2483,7 @@ const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, c
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOutput, context) => {
+const de_InternalServerExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2501,7 +2495,7 @@ const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOut
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2519,7 +2513,7 @@ const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedO
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ServiceQuotaExceededExceptionResponse = async (parsedOutput, context) => {
+const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2537,7 +2531,7 @@ const deserializeAws_restJson1ServiceQuotaExceededExceptionResponse = async (par
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput, context) => {
+const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2549,11 +2543,11 @@ const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput, context) => {
+const de_ValidationExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.fieldList != null) {
-        contents.fieldList = deserializeAws_restJson1ValidationExceptionFieldList(data.fieldList, context);
+        contents.fieldList = de_ValidationExceptionFieldList(data.fieldList, context);
     }
     if (data.message != null) {
         contents.message = __expectString(data.message);
@@ -2567,100 +2561,90 @@ const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const serializeAws_restJson1AggregateColumn = (input, context) => {
+const se_AggregateColumn = (input, context) => {
     return {
-        ...(input.columnNames != null && {
-            columnNames: serializeAws_restJson1AnalysisRuleColumnNameList(input.columnNames, context),
-        }),
+        ...(input.columnNames != null && { columnNames: se_AnalysisRuleColumnNameList(input.columnNames, context) }),
         ...(input.function != null && { function: input.function }),
     };
 };
-const serializeAws_restJson1AggregateColumnList = (input, context) => {
+const se_AggregateColumnList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1AggregateColumn(entry, context);
+        return se_AggregateColumn(entry, context);
     });
 };
-const serializeAws_restJson1AggregationConstraint = (input, context) => {
+const se_AggregationConstraint = (input, context) => {
     return {
         ...(input.columnName != null && { columnName: input.columnName }),
         ...(input.minimum != null && { minimum: input.minimum }),
         ...(input.type != null && { type: input.type }),
     };
 };
-const serializeAws_restJson1AggregationConstraints = (input, context) => {
+const se_AggregationConstraints = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1AggregationConstraint(entry, context);
+        return se_AggregationConstraint(entry, context);
     });
 };
-const serializeAws_restJson1AllowedColumnList = (input, context) => {
+const se_AllowedColumnList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1AnalysisRuleAggregation = (input, context) => {
+const se_AnalysisRuleAggregation = (input, context) => {
     return {
         ...(input.aggregateColumns != null && {
-            aggregateColumns: serializeAws_restJson1AggregateColumnList(input.aggregateColumns, context),
+            aggregateColumns: se_AggregateColumnList(input.aggregateColumns, context),
         }),
         ...(input.dimensionColumns != null && {
-            dimensionColumns: serializeAws_restJson1AnalysisRuleColumnList(input.dimensionColumns, context),
-        }),
-        ...(input.joinColumns != null && {
-            joinColumns: serializeAws_restJson1AnalysisRuleColumnList(input.joinColumns, context),
+            dimensionColumns: se_AnalysisRuleColumnList(input.dimensionColumns, context),
         }),
+        ...(input.joinColumns != null && { joinColumns: se_AnalysisRuleColumnList(input.joinColumns, context) }),
         ...(input.joinRequired != null && { joinRequired: input.joinRequired }),
         ...(input.outputConstraints != null && {
-            outputConstraints: serializeAws_restJson1AggregationConstraints(input.outputConstraints, context),
-        }),
-        ...(input.scalarFunctions != null && {
-            scalarFunctions: serializeAws_restJson1ScalarFunctionsList(input.scalarFunctions, context),
+            outputConstraints: se_AggregationConstraints(input.outputConstraints, context),
         }),
+        ...(input.scalarFunctions != null && { scalarFunctions: se_ScalarFunctionsList(input.scalarFunctions, context) }),
     };
 };
-const serializeAws_restJson1AnalysisRuleColumnList = (input, context) => {
+const se_AnalysisRuleColumnList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1AnalysisRuleColumnNameList = (input, context) => {
+const se_AnalysisRuleColumnNameList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1AnalysisRuleList = (input, context) => {
+const se_AnalysisRuleList = (input, context) => {
     return {
-        ...(input.joinColumns != null && {
-            joinColumns: serializeAws_restJson1AnalysisRuleColumnList(input.joinColumns, context),
-        }),
-        ...(input.listColumns != null && {
-            listColumns: serializeAws_restJson1AnalysisRuleColumnList(input.listColumns, context),
-        }),
+        ...(input.joinColumns != null && { joinColumns: se_AnalysisRuleColumnList(input.joinColumns, context) }),
+        ...(input.listColumns != null && { listColumns: se_AnalysisRuleColumnList(input.listColumns, context) }),
     };
 };
-const serializeAws_restJson1ConfiguredTableAnalysisRulePolicy = (input, context) => {
+const se_ConfiguredTableAnalysisRulePolicy = (input, context) => {
     return ConfiguredTableAnalysisRulePolicy.visit(input, {
-        v1: (value) => ({ v1: serializeAws_restJson1ConfiguredTableAnalysisRulePolicyV1(value, context) }),
+        v1: (value) => ({ v1: se_ConfiguredTableAnalysisRulePolicyV1(value, context) }),
         _: (name, value) => ({ name: value }),
     });
 };
-const serializeAws_restJson1ConfiguredTableAnalysisRulePolicyV1 = (input, context) => {
+const se_ConfiguredTableAnalysisRulePolicyV1 = (input, context) => {
     return ConfiguredTableAnalysisRulePolicyV1.visit(input, {
-        aggregation: (value) => ({ aggregation: serializeAws_restJson1AnalysisRuleAggregation(value, context) }),
-        list: (value) => ({ list: serializeAws_restJson1AnalysisRuleList(value, context) }),
+        aggregation: (value) => ({ aggregation: se_AnalysisRuleAggregation(value, context) }),
+        list: (value) => ({ list: se_AnalysisRuleList(value, context) }),
         _: (name, value) => ({ name: value }),
     });
 };
-const serializeAws_restJson1DataEncryptionMetadata = (input, context) => {
+const se_DataEncryptionMetadata = (input, context) => {
     return {
         ...(input.allowCleartext != null && { allowCleartext: input.allowCleartext }),
         ...(input.allowDuplicates != null && { allowDuplicates: input.allowDuplicates }),
@@ -2670,81 +2654,79 @@ const serializeAws_restJson1DataEncryptionMetadata = (input, context) => {
         ...(input.preserveNulls != null && { preserveNulls: input.preserveNulls }),
     };
 };
-const serializeAws_restJson1GlueTableReference = (input, context) => {
+const se_GlueTableReference = (input, context) => {
     return {
         ...(input.databaseName != null && { databaseName: input.databaseName }),
         ...(input.tableName != null && { tableName: input.tableName }),
     };
 };
-const serializeAws_restJson1MemberAbilities = (input, context) => {
+const se_MemberAbilities = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1MemberList = (input, context) => {
+const se_MemberList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1MemberSpecification(entry, context);
+        return se_MemberSpecification(entry, context);
     });
 };
-const serializeAws_restJson1MemberSpecification = (input, context) => {
+const se_MemberSpecification = (input, context) => {
     return {
         ...(input.accountId != null && { accountId: input.accountId }),
         ...(input.displayName != null && { displayName: input.displayName }),
-        ...(input.memberAbilities != null && {
-            memberAbilities: serializeAws_restJson1MemberAbilities(input.memberAbilities, context),
-        }),
+        ...(input.memberAbilities != null && { memberAbilities: se_MemberAbilities(input.memberAbilities, context) }),
     };
 };
-const serializeAws_restJson1ProtectedQueryOutputConfiguration = (input, context) => {
+const se_ProtectedQueryOutputConfiguration = (input, context) => {
     return ProtectedQueryOutputConfiguration.visit(input, {
-        s3: (value) => ({ s3: serializeAws_restJson1ProtectedQueryS3OutputConfiguration(value, context) }),
+        s3: (value) => ({ s3: se_ProtectedQueryS3OutputConfiguration(value, context) }),
         _: (name, value) => ({ name: value }),
     });
 };
-const serializeAws_restJson1ProtectedQueryResultConfiguration = (input, context) => {
+const se_ProtectedQueryResultConfiguration = (input, context) => {
     return {
         ...(input.outputConfiguration != null && {
-            outputConfiguration: serializeAws_restJson1ProtectedQueryOutputConfiguration(input.outputConfiguration, context),
+            outputConfiguration: se_ProtectedQueryOutputConfiguration(input.outputConfiguration, context),
         }),
     };
 };
-const serializeAws_restJson1ProtectedQueryS3OutputConfiguration = (input, context) => {
+const se_ProtectedQueryS3OutputConfiguration = (input, context) => {
     return {
         ...(input.bucket != null && { bucket: input.bucket }),
         ...(input.keyPrefix != null && { keyPrefix: input.keyPrefix }),
         ...(input.resultFormat != null && { resultFormat: input.resultFormat }),
     };
 };
-const serializeAws_restJson1ProtectedQuerySQLParameters = (input, context) => {
+const se_ProtectedQuerySQLParameters = (input, context) => {
     return {
         ...(input.queryString != null && { queryString: input.queryString }),
     };
 };
-const serializeAws_restJson1ScalarFunctionsList = (input, context) => {
+const se_ScalarFunctionsList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1TableAliasList = (input, context) => {
+const se_TableAliasList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1TableReference = (input, context) => {
+const se_TableReference = (input, context) => {
     return TableReference.visit(input, {
-        glue: (value) => ({ glue: serializeAws_restJson1GlueTableReference(value, context) }),
+        glue: (value) => ({ glue: se_GlueTableReference(value, context) }),
         _: (name, value) => ({ name: value }),
     });
 };
-const serializeAws_restJson1TagMap = (input, context) => {
+const se_TagMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -2753,44 +2735,42 @@ const serializeAws_restJson1TagMap = (input, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_restJson1AggregateColumn = (output, context) => {
+const de_AggregateColumn = (output, context) => {
     return {
-        columnNames: output.columnNames != null
-            ? deserializeAws_restJson1AnalysisRuleColumnNameList(output.columnNames, context)
-            : undefined,
+        columnNames: output.columnNames != null ? de_AnalysisRuleColumnNameList(output.columnNames, context) : undefined,
         function: __expectString(output.function),
     };
 };
-const deserializeAws_restJson1AggregateColumnList = (output, context) => {
+const de_AggregateColumnList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AggregateColumn(entry, context);
+        return de_AggregateColumn(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AggregationConstraint = (output, context) => {
+const de_AggregationConstraint = (output, context) => {
     return {
         columnName: __expectString(output.columnName),
         minimum: __expectInt32(output.minimum),
         type: __expectString(output.type),
     };
 };
-const deserializeAws_restJson1AggregationConstraints = (output, context) => {
+const de_AggregationConstraints = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AggregationConstraint(entry, context);
+        return de_AggregationConstraint(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AllowedColumnList = (output, context) => {
+const de_AllowedColumnList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2801,39 +2781,27 @@ const deserializeAws_restJson1AllowedColumnList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1AnalysisRule = (output, context) => {
+const de_AnalysisRule = (output, context) => {
     return {
         collaborationId: __expectString(output.collaborationId),
         createTime: output.createTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createTime))) : undefined,
         name: __expectString(output.name),
-        policy: output.policy != null
-            ? deserializeAws_restJson1AnalysisRulePolicy(__expectUnion(output.policy), context)
-            : undefined,
+        policy: output.policy != null ? de_AnalysisRulePolicy(__expectUnion(output.policy), context) : undefined,
         type: __expectString(output.type),
         updateTime: output.updateTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updateTime))) : undefined,
     };
 };
-const deserializeAws_restJson1AnalysisRuleAggregation = (output, context) => {
+const de_AnalysisRuleAggregation = (output, context) => {
     return {
-        aggregateColumns: output.aggregateColumns != null
-            ? deserializeAws_restJson1AggregateColumnList(output.aggregateColumns, context)
-            : undefined,
-        dimensionColumns: output.dimensionColumns != null
-            ? deserializeAws_restJson1AnalysisRuleColumnList(output.dimensionColumns, context)
-            : undefined,
-        joinColumns: output.joinColumns != null
-            ? deserializeAws_restJson1AnalysisRuleColumnList(output.joinColumns, context)
-            : undefined,
+        aggregateColumns: output.aggregateColumns != null ? de_AggregateColumnList(output.aggregateColumns, context) : undefined,
+        dimensionColumns: output.dimensionColumns != null ? de_AnalysisRuleColumnList(output.dimensionColumns, context) : undefined,
+        joinColumns: output.joinColumns != null ? de_AnalysisRuleColumnList(output.joinColumns, context) : undefined,
         joinRequired: __expectString(output.joinRequired),
-        outputConstraints: output.outputConstraints != null
-            ? deserializeAws_restJson1AggregationConstraints(output.outputConstraints, context)
-            : undefined,
-        scalarFunctions: output.scalarFunctions != null
-            ? deserializeAws_restJson1ScalarFunctionsList(output.scalarFunctions, context)
-            : undefined,
+        outputConstraints: output.outputConstraints != null ? de_AggregationConstraints(output.outputConstraints, context) : undefined,
+        scalarFunctions: output.scalarFunctions != null ? de_ScalarFunctionsList(output.scalarFunctions, context) : undefined,
     };
 };
-const deserializeAws_restJson1AnalysisRuleColumnList = (output, context) => {
+const de_AnalysisRuleColumnList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2844,7 +2812,7 @@ const deserializeAws_restJson1AnalysisRuleColumnList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1AnalysisRuleColumnNameList = (output, context) => {
+const de_AnalysisRuleColumnNameList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2855,38 +2823,34 @@ const deserializeAws_restJson1AnalysisRuleColumnNameList = (output, context) =>
     });
     return retVal;
 };
-const deserializeAws_restJson1AnalysisRuleList = (output, context) => {
+const de_AnalysisRuleList = (output, context) => {
     return {
-        joinColumns: output.joinColumns != null
-            ? deserializeAws_restJson1AnalysisRuleColumnList(output.joinColumns, context)
-            : undefined,
-        listColumns: output.listColumns != null
-            ? deserializeAws_restJson1AnalysisRuleColumnList(output.listColumns, context)
-            : undefined,
+        joinColumns: output.joinColumns != null ? de_AnalysisRuleColumnList(output.joinColumns, context) : undefined,
+        listColumns: output.listColumns != null ? de_AnalysisRuleColumnList(output.listColumns, context) : undefined,
     };
 };
-const deserializeAws_restJson1AnalysisRulePolicy = (output, context) => {
+const de_AnalysisRulePolicy = (output, context) => {
     if (output.v1 != null) {
         return {
-            v1: deserializeAws_restJson1AnalysisRulePolicyV1(__expectUnion(output.v1), context),
+            v1: de_AnalysisRulePolicyV1(__expectUnion(output.v1), context),
         };
     }
     return { $unknown: Object.entries(output)[0] };
 };
-const deserializeAws_restJson1AnalysisRulePolicyV1 = (output, context) => {
+const de_AnalysisRulePolicyV1 = (output, context) => {
     if (output.aggregation != null) {
         return {
-            aggregation: deserializeAws_restJson1AnalysisRuleAggregation(output.aggregation, context),
+            aggregation: de_AnalysisRuleAggregation(output.aggregation, context),
         };
     }
     if (output.list != null) {
         return {
-            list: deserializeAws_restJson1AnalysisRuleList(output.list, context),
+            list: de_AnalysisRuleList(output.list, context),
         };
     }
     return { $unknown: Object.entries(output)[0] };
 };
-const deserializeAws_restJson1AnalysisRuleTypeList = (output, context) => {
+const de_AnalysisRuleTypeList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2897,32 +2861,32 @@ const deserializeAws_restJson1AnalysisRuleTypeList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1BatchGetSchemaError = (output, context) => {
+const de_BatchGetSchemaError = (output, context) => {
     return {
         code: __expectString(output.code),
         message: __expectString(output.message),
         name: __expectString(output.name),
     };
 };
-const deserializeAws_restJson1BatchGetSchemaErrorList = (output, context) => {
+const de_BatchGetSchemaErrorList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1BatchGetSchemaError(entry, context);
+        return de_BatchGetSchemaError(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1Collaboration = (output, context) => {
+const de_Collaboration = (output, context) => {
     return {
         arn: __expectString(output.arn),
         createTime: output.createTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createTime))) : undefined,
         creatorAccountId: __expectString(output.creatorAccountId),
         creatorDisplayName: __expectString(output.creatorDisplayName),
         dataEncryptionMetadata: output.dataEncryptionMetadata != null
-            ? deserializeAws_restJson1DataEncryptionMetadata(output.dataEncryptionMetadata, context)
+            ? de_DataEncryptionMetadata(output.dataEncryptionMetadata, context)
             : undefined,
         description: __expectString(output.description),
         id: __expectString(output.id),
@@ -2934,7 +2898,7 @@ const deserializeAws_restJson1Collaboration = (output, context) => {
         updateTime: output.updateTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updateTime))) : undefined,
     };
 };
-const deserializeAws_restJson1CollaborationSummary = (output, context) => {
+const de_CollaborationSummary = (output, context) => {
     return {
         arn: __expectString(output.arn),
         createTime: output.createTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createTime))) : undefined,
@@ -2948,88 +2912,82 @@ const deserializeAws_restJson1CollaborationSummary = (output, context) => {
         updateTime: output.updateTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updateTime))) : undefined,
     };
 };
-const deserializeAws_restJson1CollaborationSummaryList = (output, context) => {
+const de_CollaborationSummaryList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1CollaborationSummary(entry, context);
+        return de_CollaborationSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1Column = (output, context) => {
+const de_Column = (output, context) => {
     return {
         name: __expectString(output.name),
         type: __expectString(output.type),
     };
 };
-const deserializeAws_restJson1ColumnList = (output, context) => {
+const de_ColumnList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Column(entry, context);
+        return de_Column(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ConfiguredTable = (output, context) => {
+const de_ConfiguredTable = (output, context) => {
     return {
-        allowedColumns: output.allowedColumns != null
-            ? deserializeAws_restJson1AllowedColumnList(output.allowedColumns, context)
-            : undefined,
+        allowedColumns: output.allowedColumns != null ? de_AllowedColumnList(output.allowedColumns, context) : undefined,
         analysisMethod: __expectString(output.analysisMethod),
         analysisRuleTypes: output.analysisRuleTypes != null
-            ? deserializeAws_restJson1ConfiguredTableAnalysisRuleTypeList(output.analysisRuleTypes, context)
+            ? de_ConfiguredTableAnalysisRuleTypeList(output.analysisRuleTypes, context)
             : undefined,
         arn: __expectString(output.arn),
         createTime: output.createTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createTime))) : undefined,
         description: __expectString(output.description),
         id: __expectString(output.id),
         name: __expectString(output.name),
-        tableReference: output.tableReference != null
-            ? deserializeAws_restJson1TableReference(__expectUnion(output.tableReference), context)
-            : undefined,
+        tableReference: output.tableReference != null ? de_TableReference(__expectUnion(output.tableReference), context) : undefined,
         updateTime: output.updateTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updateTime))) : undefined,
     };
 };
-const deserializeAws_restJson1ConfiguredTableAnalysisRule = (output, context) => {
+const de_ConfiguredTableAnalysisRule = (output, context) => {
     return {
         configuredTableArn: __expectString(output.configuredTableArn),
         configuredTableId: __expectString(output.configuredTableId),
         createTime: output.createTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createTime))) : undefined,
-        policy: output.policy != null
-            ? deserializeAws_restJson1ConfiguredTableAnalysisRulePolicy(__expectUnion(output.policy), context)
-            : undefined,
+        policy: output.policy != null ? de_ConfiguredTableAnalysisRulePolicy(__expectUnion(output.policy), context) : undefined,
         type: __expectString(output.type),
         updateTime: output.updateTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updateTime))) : undefined,
     };
 };
-const deserializeAws_restJson1ConfiguredTableAnalysisRulePolicy = (output, context) => {
+const de_ConfiguredTableAnalysisRulePolicy = (output, context) => {
     if (output.v1 != null) {
         return {
-            v1: deserializeAws_restJson1ConfiguredTableAnalysisRulePolicyV1(__expectUnion(output.v1), context),
+            v1: de_ConfiguredTableAnalysisRulePolicyV1(__expectUnion(output.v1), context),
         };
     }
     return { $unknown: Object.entries(output)[0] };
 };
-const deserializeAws_restJson1ConfiguredTableAnalysisRulePolicyV1 = (output, context) => {
+const de_ConfiguredTableAnalysisRulePolicyV1 = (output, context) => {
     if (output.aggregation != null) {
         return {
-            aggregation: deserializeAws_restJson1AnalysisRuleAggregation(output.aggregation, context),
+            aggregation: de_AnalysisRuleAggregation(output.aggregation, context),
         };
     }
     if (output.list != null) {
         return {
-            list: deserializeAws_restJson1AnalysisRuleList(output.list, context),
+            list: de_AnalysisRuleList(output.list, context),
         };
     }
     return { $unknown: Object.entries(output)[0] };
 };
-const deserializeAws_restJson1ConfiguredTableAnalysisRuleTypeList = (output, context) => {
+const de_ConfiguredTableAnalysisRuleTypeList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -3040,7 +2998,7 @@ const deserializeAws_restJson1ConfiguredTableAnalysisRuleTypeList = (output, con
     });
     return retVal;
 };
-const deserializeAws_restJson1ConfiguredTableAssociation = (output, context) => {
+const de_ConfiguredTableAssociation = (output, context) => {
     return {
         arn: __expectString(output.arn),
         configuredTableArn: __expectString(output.configuredTableArn),
@@ -3055,7 +3013,7 @@ const deserializeAws_restJson1ConfiguredTableAssociation = (output, context) =>
         updateTime: output.updateTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updateTime))) : undefined,
     };
 };
-const deserializeAws_restJson1ConfiguredTableAssociationSummary = (output, context) => {
+const de_ConfiguredTableAssociationSummary = (output, context) => {
     return {
         arn: __expectString(output.arn),
         configuredTableId: __expectString(output.configuredTableId),
@@ -3067,22 +3025,22 @@ const deserializeAws_restJson1ConfiguredTableAssociationSummary = (output, conte
         updateTime: output.updateTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updateTime))) : undefined,
     };
 };
-const deserializeAws_restJson1ConfiguredTableAssociationSummaryList = (output, context) => {
+const de_ConfiguredTableAssociationSummaryList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ConfiguredTableAssociationSummary(entry, context);
+        return de_ConfiguredTableAssociationSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ConfiguredTableSummary = (output, context) => {
+const de_ConfiguredTableSummary = (output, context) => {
     return {
         analysisMethod: __expectString(output.analysisMethod),
         analysisRuleTypes: output.analysisRuleTypes != null
-            ? deserializeAws_restJson1ConfiguredTableAnalysisRuleTypeList(output.analysisRuleTypes, context)
+            ? de_ConfiguredTableAnalysisRuleTypeList(output.analysisRuleTypes, context)
             : undefined,
         arn: __expectString(output.arn),
         createTime: output.createTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createTime))) : undefined,
@@ -3091,18 +3049,18 @@ const deserializeAws_restJson1ConfiguredTableSummary = (output, context) => {
         updateTime: output.updateTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updateTime))) : undefined,
     };
 };
-const deserializeAws_restJson1ConfiguredTableSummaryList = (output, context) => {
+const de_ConfiguredTableSummaryList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ConfiguredTableSummary(entry, context);
+        return de_ConfiguredTableSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1DataEncryptionMetadata = (output, context) => {
+const de_DataEncryptionMetadata = (output, context) => {
     return {
         allowCleartext: __expectBoolean(output.allowCleartext),
         allowDuplicates: __expectBoolean(output.allowDuplicates),
@@ -3110,13 +3068,13 @@ const deserializeAws_restJson1DataEncryptionMetadata = (output, context) => {
         preserveNulls: __expectBoolean(output.preserveNulls),
     };
 };
-const deserializeAws_restJson1GlueTableReference = (output, context) => {
+const de_GlueTableReference = (output, context) => {
     return {
         databaseName: __expectString(output.databaseName),
         tableName: __expectString(output.tableName),
     };
 };
-const deserializeAws_restJson1MemberAbilities = (output, context) => {
+const de_MemberAbilities = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -3127,7 +3085,7 @@ const deserializeAws_restJson1MemberAbilities = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1Membership = (output, context) => {
+const de_Membership = (output, context) => {
     return {
         arn: __expectString(output.arn),
         collaborationArn: __expectString(output.collaborationArn),
@@ -3137,15 +3095,13 @@ const deserializeAws_restJson1Membership = (output, context) => {
         collaborationName: __expectString(output.collaborationName),
         createTime: output.createTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createTime))) : undefined,
         id: __expectString(output.id),
-        memberAbilities: output.memberAbilities != null
-            ? deserializeAws_restJson1MemberAbilities(output.memberAbilities, context)
-            : undefined,
+        memberAbilities: output.memberAbilities != null ? de_MemberAbilities(output.memberAbilities, context) : undefined,
         queryLogStatus: __expectString(output.queryLogStatus),
         status: __expectString(output.status),
         updateTime: output.updateTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updateTime))) : undefined,
     };
 };
-const deserializeAws_restJson1MembershipSummary = (output, context) => {
+const de_MembershipSummary = (output, context) => {
     return {
         arn: __expectString(output.arn),
         collaborationArn: __expectString(output.collaborationArn),
@@ -3155,27 +3111,25 @@ const deserializeAws_restJson1MembershipSummary = (output, context) => {
         collaborationName: __expectString(output.collaborationName),
         createTime: output.createTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createTime))) : undefined,
         id: __expectString(output.id),
-        memberAbilities: output.memberAbilities != null
-            ? deserializeAws_restJson1MemberAbilities(output.memberAbilities, context)
-            : undefined,
+        memberAbilities: output.memberAbilities != null ? de_MemberAbilities(output.memberAbilities, context) : undefined,
         status: __expectString(output.status),
         updateTime: output.updateTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updateTime))) : undefined,
     };
 };
-const deserializeAws_restJson1MembershipSummaryList = (output, context) => {
+const de_MembershipSummaryList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1MembershipSummary(entry, context);
+        return de_MembershipSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1MemberSummary = (output, context) => {
+const de_MemberSummary = (output, context) => {
     return {
-        abilities: output.abilities != null ? deserializeAws_restJson1MemberAbilities(output.abilities, context) : undefined,
+        abilities: output.abilities != null ? de_MemberAbilities(output.abilities, context) : undefined,
         accountId: __expectString(output.accountId),
         createTime: output.createTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createTime))) : undefined,
         displayName: __expectString(output.displayName),
@@ -3185,96 +3139,90 @@ const deserializeAws_restJson1MemberSummary = (output, context) => {
         updateTime: output.updateTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updateTime))) : undefined,
     };
 };
-const deserializeAws_restJson1MemberSummaryList = (output, context) => {
+const de_MemberSummaryList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1MemberSummary(entry, context);
+        return de_MemberSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ProtectedQuery = (output, context) => {
+const de_ProtectedQuery = (output, context) => {
     return {
         createTime: output.createTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createTime))) : undefined,
-        error: output.error != null ? deserializeAws_restJson1ProtectedQueryError(output.error, context) : undefined,
+        error: output.error != null ? de_ProtectedQueryError(output.error, context) : undefined,
         id: __expectString(output.id),
         membershipArn: __expectString(output.membershipArn),
         membershipId: __expectString(output.membershipId),
-        result: output.result != null ? deserializeAws_restJson1ProtectedQueryResult(output.result, context) : undefined,
+        result: output.result != null ? de_ProtectedQueryResult(output.result, context) : undefined,
         resultConfiguration: output.resultConfiguration != null
-            ? deserializeAws_restJson1ProtectedQueryResultConfiguration(output.resultConfiguration, context)
-            : undefined,
-        sqlParameters: output.sqlParameters != null
-            ? deserializeAws_restJson1ProtectedQuerySQLParameters(output.sqlParameters, context)
-            : undefined,
-        statistics: output.statistics != null
-            ? deserializeAws_restJson1ProtectedQueryStatistics(output.statistics, context)
+            ? de_ProtectedQueryResultConfiguration(output.resultConfiguration, context)
             : undefined,
+        sqlParameters: output.sqlParameters != null ? de_ProtectedQuerySQLParameters(output.sqlParameters, context) : undefined,
+        statistics: output.statistics != null ? de_ProtectedQueryStatistics(output.statistics, context) : undefined,
         status: __expectString(output.status),
     };
 };
-const deserializeAws_restJson1ProtectedQueryError = (output, context) => {
+const de_ProtectedQueryError = (output, context) => {
     return {
         code: __expectString(output.code),
         message: __expectString(output.message),
     };
 };
-const deserializeAws_restJson1ProtectedQueryOutput = (output, context) => {
+const de_ProtectedQueryOutput = (output, context) => {
     if (output.s3 != null) {
         return {
-            s3: deserializeAws_restJson1ProtectedQueryS3Output(output.s3, context),
+            s3: de_ProtectedQueryS3Output(output.s3, context),
         };
     }
     return { $unknown: Object.entries(output)[0] };
 };
-const deserializeAws_restJson1ProtectedQueryOutputConfiguration = (output, context) => {
+const de_ProtectedQueryOutputConfiguration = (output, context) => {
     if (output.s3 != null) {
         return {
-            s3: deserializeAws_restJson1ProtectedQueryS3OutputConfiguration(output.s3, context),
+            s3: de_ProtectedQueryS3OutputConfiguration(output.s3, context),
         };
     }
     return { $unknown: Object.entries(output)[0] };
 };
-const deserializeAws_restJson1ProtectedQueryResult = (output, context) => {
+const de_ProtectedQueryResult = (output, context) => {
     return {
-        output: output.output != null
-            ? deserializeAws_restJson1ProtectedQueryOutput(__expectUnion(output.output), context)
-            : undefined,
+        output: output.output != null ? de_ProtectedQueryOutput(__expectUnion(output.output), context) : undefined,
     };
 };
-const deserializeAws_restJson1ProtectedQueryResultConfiguration = (output, context) => {
+const de_ProtectedQueryResultConfiguration = (output, context) => {
     return {
         outputConfiguration: output.outputConfiguration != null
-            ? deserializeAws_restJson1ProtectedQueryOutputConfiguration(__expectUnion(output.outputConfiguration), context)
+            ? de_ProtectedQueryOutputConfiguration(__expectUnion(output.outputConfiguration), context)
             : undefined,
     };
 };
-const deserializeAws_restJson1ProtectedQueryS3Output = (output, context) => {
+const de_ProtectedQueryS3Output = (output, context) => {
     return {
         location: __expectString(output.location),
     };
 };
-const deserializeAws_restJson1ProtectedQueryS3OutputConfiguration = (output, context) => {
+const de_ProtectedQueryS3OutputConfiguration = (output, context) => {
     return {
         bucket: __expectString(output.bucket),
         keyPrefix: __expectString(output.keyPrefix),
         resultFormat: __expectString(output.resultFormat),
     };
 };
-const deserializeAws_restJson1ProtectedQuerySQLParameters = (output, context) => {
+const de_ProtectedQuerySQLParameters = (output, context) => {
     return {
         queryString: __expectString(output.queryString),
     };
 };
-const deserializeAws_restJson1ProtectedQueryStatistics = (output, context) => {
+const de_ProtectedQueryStatistics = (output, context) => {
     return {
         totalDurationInMillis: __expectLong(output.totalDurationInMillis),
     };
 };
-const deserializeAws_restJson1ProtectedQuerySummary = (output, context) => {
+const de_ProtectedQuerySummary = (output, context) => {
     return {
         createTime: output.createTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createTime))) : undefined,
         id: __expectString(output.id),
@@ -3283,18 +3231,18 @@ const deserializeAws_restJson1ProtectedQuerySummary = (output, context) => {
         status: __expectString(output.status),
     };
 };
-const deserializeAws_restJson1ProtectedQuerySummaryList = (output, context) => {
+const de_ProtectedQuerySummaryList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ProtectedQuerySummary(entry, context);
+        return de_ProtectedQuerySummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ScalarFunctionsList = (output, context) => {
+const de_ScalarFunctionsList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -3305,41 +3253,37 @@ const deserializeAws_restJson1ScalarFunctionsList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1Schema = (output, context) => {
+const de_Schema = (output, context) => {
     return {
         analysisMethod: __expectString(output.analysisMethod),
-        analysisRuleTypes: output.analysisRuleTypes != null
-            ? deserializeAws_restJson1AnalysisRuleTypeList(output.analysisRuleTypes, context)
-            : undefined,
+        analysisRuleTypes: output.analysisRuleTypes != null ? de_AnalysisRuleTypeList(output.analysisRuleTypes, context) : undefined,
         collaborationArn: __expectString(output.collaborationArn),
         collaborationId: __expectString(output.collaborationId),
-        columns: output.columns != null ? deserializeAws_restJson1ColumnList(output.columns, context) : undefined,
+        columns: output.columns != null ? de_ColumnList(output.columns, context) : undefined,
         createTime: output.createTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createTime))) : undefined,
         creatorAccountId: __expectString(output.creatorAccountId),
         description: __expectString(output.description),
         name: __expectString(output.name),
-        partitionKeys: output.partitionKeys != null ? deserializeAws_restJson1ColumnList(output.partitionKeys, context) : undefined,
+        partitionKeys: output.partitionKeys != null ? de_ColumnList(output.partitionKeys, context) : undefined,
         type: __expectString(output.type),
         updateTime: output.updateTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updateTime))) : undefined,
     };
 };
-const deserializeAws_restJson1SchemaList = (output, context) => {
+const de_SchemaList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Schema(entry, context);
+        return de_Schema(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1SchemaSummary = (output, context) => {
+const de_SchemaSummary = (output, context) => {
     return {
         analysisMethod: __expectString(output.analysisMethod),
-        analysisRuleTypes: output.analysisRuleTypes != null
-            ? deserializeAws_restJson1AnalysisRuleTypeList(output.analysisRuleTypes, context)
-            : undefined,
+        analysisRuleTypes: output.analysisRuleTypes != null ? de_AnalysisRuleTypeList(output.analysisRuleTypes, context) : undefined,
         collaborationArn: __expectString(output.collaborationArn),
         collaborationId: __expectString(output.collaborationId),
         createTime: output.createTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createTime))) : undefined,
@@ -3349,26 +3293,26 @@ const deserializeAws_restJson1SchemaSummary = (output, context) => {
         updateTime: output.updateTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updateTime))) : undefined,
     };
 };
-const deserializeAws_restJson1SchemaSummaryList = (output, context) => {
+const de_SchemaSummaryList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1SchemaSummary(entry, context);
+        return de_SchemaSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1TableReference = (output, context) => {
+const de_TableReference = (output, context) => {
     if (output.glue != null) {
         return {
-            glue: deserializeAws_restJson1GlueTableReference(output.glue, context),
+            glue: de_GlueTableReference(output.glue, context),
         };
     }
     return { $unknown: Object.entries(output)[0] };
 };
-const deserializeAws_restJson1TagMap = (output, context) => {
+const de_TagMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -3377,20 +3321,20 @@ const deserializeAws_restJson1TagMap = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_restJson1ValidationExceptionField = (output, context) => {
+const de_ValidationExceptionField = (output, context) => {
     return {
         message: __expectString(output.message),
         name: __expectString(output.name),
     };
 };
-const deserializeAws_restJson1ValidationExceptionFieldList = (output, context) => {
+const de_ValidationExceptionFieldList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ValidationExceptionField(entry, context);
+        return de_ValidationExceptionField(entry, context);
     });
     return retVal;
 };