@aws-sdk/client-appsync 3.303.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, expectObject as __expectObject, expectString as __expectString, map as __map, resolvedPath as __resolvedPath, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { AppSyncServiceException as __BaseException } from "../models/AppSyncServiceException";
 import { AccessDeniedException, ApiKeyLimitExceededException, ApiKeyValidityOutOfBoundsException, ApiLimitExceededException, BadRequestException, ConcurrentModificationException, GraphQLSchemaException, InternalFailureException, LimitExceededException, NotFoundException, UnauthorizedException, } from "../models/models_0";
-export const serializeAws_restJson1AssociateApiCommand = async (input, context) => {
+export const se_AssociateApiCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -24,7 +24,7 @@ export const serializeAws_restJson1AssociateApiCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1CreateApiCacheCommand = async (input, context) => {
+export const se_CreateApiCacheCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -49,7 +49,7 @@ export const serializeAws_restJson1CreateApiCacheCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1CreateApiKeyCommand = async (input, context) => {
+export const se_CreateApiKeyCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -71,7 +71,7 @@ export const serializeAws_restJson1CreateApiKeyCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1CreateDataSourceCommand = async (input, context) => {
+export const se_CreateDataSourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -81,27 +81,21 @@ export const serializeAws_restJson1CreateDataSourceCommand = async (input, conte
     let body;
     body = JSON.stringify({
         ...(input.description != null && { description: input.description }),
-        ...(input.dynamodbConfig != null && {
-            dynamodbConfig: serializeAws_restJson1DynamodbDataSourceConfig(input.dynamodbConfig, context),
-        }),
+        ...(input.dynamodbConfig != null && { dynamodbConfig: se_DynamodbDataSourceConfig(input.dynamodbConfig, context) }),
         ...(input.elasticsearchConfig != null && {
-            elasticsearchConfig: serializeAws_restJson1ElasticsearchDataSourceConfig(input.elasticsearchConfig, context),
+            elasticsearchConfig: se_ElasticsearchDataSourceConfig(input.elasticsearchConfig, context),
         }),
         ...(input.eventBridgeConfig != null && {
-            eventBridgeConfig: serializeAws_restJson1EventBridgeDataSourceConfig(input.eventBridgeConfig, context),
-        }),
-        ...(input.httpConfig != null && {
-            httpConfig: serializeAws_restJson1HttpDataSourceConfig(input.httpConfig, context),
-        }),
-        ...(input.lambdaConfig != null && {
-            lambdaConfig: serializeAws_restJson1LambdaDataSourceConfig(input.lambdaConfig, context),
+            eventBridgeConfig: se_EventBridgeDataSourceConfig(input.eventBridgeConfig, context),
         }),
+        ...(input.httpConfig != null && { httpConfig: se_HttpDataSourceConfig(input.httpConfig, context) }),
+        ...(input.lambdaConfig != null && { lambdaConfig: se_LambdaDataSourceConfig(input.lambdaConfig, context) }),
         ...(input.name != null && { name: input.name }),
         ...(input.openSearchServiceConfig != null && {
-            openSearchServiceConfig: serializeAws_restJson1OpenSearchServiceDataSourceConfig(input.openSearchServiceConfig, context),
+            openSearchServiceConfig: se_OpenSearchServiceDataSourceConfig(input.openSearchServiceConfig, context),
         }),
         ...(input.relationalDatabaseConfig != null && {
-            relationalDatabaseConfig: serializeAws_restJson1RelationalDatabaseDataSourceConfig(input.relationalDatabaseConfig, context),
+            relationalDatabaseConfig: se_RelationalDatabaseDataSourceConfig(input.relationalDatabaseConfig, context),
         }),
         ...(input.serviceRoleArn != null && { serviceRoleArn: input.serviceRoleArn }),
         ...(input.type != null && { type: input.type }),
@@ -116,7 +110,7 @@ export const serializeAws_restJson1CreateDataSourceCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1CreateDomainNameCommand = async (input, context) => {
+export const se_CreateDomainNameCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -138,7 +132,7 @@ export const serializeAws_restJson1CreateDomainNameCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1CreateFunctionCommand = async (input, context) => {
+export const se_CreateFunctionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -155,8 +149,8 @@ export const serializeAws_restJson1CreateFunctionCommand = async (input, context
         ...(input.name != null && { name: input.name }),
         ...(input.requestMappingTemplate != null && { requestMappingTemplate: input.requestMappingTemplate }),
         ...(input.responseMappingTemplate != null && { responseMappingTemplate: input.responseMappingTemplate }),
-        ...(input.runtime != null && { runtime: serializeAws_restJson1AppSyncRuntime(input.runtime, context) }),
-        ...(input.syncConfig != null && { syncConfig: serializeAws_restJson1SyncConfig(input.syncConfig, context) }),
+        ...(input.runtime != null && { runtime: se_AppSyncRuntime(input.runtime, context) }),
+        ...(input.syncConfig != null && { syncConfig: se_SyncConfig(input.syncConfig, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -168,7 +162,7 @@ export const serializeAws_restJson1CreateFunctionCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1CreateGraphqlApiCommand = async (input, context) => {
+export const se_CreateGraphqlApiCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -177,21 +171,19 @@ export const serializeAws_restJson1CreateGraphqlApiCommand = async (input, conte
     let body;
     body = JSON.stringify({
         ...(input.additionalAuthenticationProviders != null && {
-            additionalAuthenticationProviders: serializeAws_restJson1AdditionalAuthenticationProviders(input.additionalAuthenticationProviders, context),
+            additionalAuthenticationProviders: se_AdditionalAuthenticationProviders(input.additionalAuthenticationProviders, context),
         }),
         ...(input.authenticationType != null && { authenticationType: input.authenticationType }),
         ...(input.lambdaAuthorizerConfig != null && {
-            lambdaAuthorizerConfig: serializeAws_restJson1LambdaAuthorizerConfig(input.lambdaAuthorizerConfig, context),
+            lambdaAuthorizerConfig: se_LambdaAuthorizerConfig(input.lambdaAuthorizerConfig, context),
         }),
-        ...(input.logConfig != null && { logConfig: serializeAws_restJson1LogConfig(input.logConfig, context) }),
+        ...(input.logConfig != null && { logConfig: se_LogConfig(input.logConfig, context) }),
         ...(input.name != null && { name: input.name }),
         ...(input.openIDConnectConfig != null && {
-            openIDConnectConfig: serializeAws_restJson1OpenIDConnectConfig(input.openIDConnectConfig, context),
-        }),
-        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
-        ...(input.userPoolConfig != null && {
-            userPoolConfig: serializeAws_restJson1UserPoolConfig(input.userPoolConfig, context),
+            openIDConnectConfig: se_OpenIDConnectConfig(input.openIDConnectConfig, context),
         }),
+        ...(input.tags != null && { tags: se_TagMap(input.tags, context) }),
+        ...(input.userPoolConfig != null && { userPoolConfig: se_UserPoolConfig(input.userPoolConfig, context) }),
         ...(input.xrayEnabled != null && { xrayEnabled: input.xrayEnabled }),
     });
     return new __HttpRequest({
@@ -204,7 +196,7 @@ export const serializeAws_restJson1CreateGraphqlApiCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1CreateResolverCommand = async (input, context) => {
+export const se_CreateResolverCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -215,21 +207,17 @@ export const serializeAws_restJson1CreateResolverCommand = async (input, context
     resolvedPath = __resolvedPath(resolvedPath, input, "typeName", () => input.typeName, "{typeName}", false);
     let body;
     body = JSON.stringify({
-        ...(input.cachingConfig != null && {
-            cachingConfig: serializeAws_restJson1CachingConfig(input.cachingConfig, context),
-        }),
+        ...(input.cachingConfig != null && { cachingConfig: se_CachingConfig(input.cachingConfig, context) }),
         ...(input.code != null && { code: input.code }),
         ...(input.dataSourceName != null && { dataSourceName: input.dataSourceName }),
         ...(input.fieldName != null && { fieldName: input.fieldName }),
         ...(input.kind != null && { kind: input.kind }),
         ...(input.maxBatchSize != null && { maxBatchSize: input.maxBatchSize }),
-        ...(input.pipelineConfig != null && {
-            pipelineConfig: serializeAws_restJson1PipelineConfig(input.pipelineConfig, context),
-        }),
+        ...(input.pipelineConfig != null && { pipelineConfig: se_PipelineConfig(input.pipelineConfig, context) }),
         ...(input.requestMappingTemplate != null && { requestMappingTemplate: input.requestMappingTemplate }),
         ...(input.responseMappingTemplate != null && { responseMappingTemplate: input.responseMappingTemplate }),
-        ...(input.runtime != null && { runtime: serializeAws_restJson1AppSyncRuntime(input.runtime, context) }),
-        ...(input.syncConfig != null && { syncConfig: serializeAws_restJson1SyncConfig(input.syncConfig, context) }),
+        ...(input.runtime != null && { runtime: se_AppSyncRuntime(input.runtime, context) }),
+        ...(input.syncConfig != null && { syncConfig: se_SyncConfig(input.syncConfig, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -241,7 +229,7 @@ export const serializeAws_restJson1CreateResolverCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1CreateTypeCommand = async (input, context) => {
+export const se_CreateTypeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -263,7 +251,7 @@ export const serializeAws_restJson1CreateTypeCommand = async (input, context) =>
         body,
     });
 };
-export const serializeAws_restJson1DeleteApiCacheCommand = async (input, context) => {
+export const se_DeleteApiCacheCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/ApiCaches";
@@ -279,7 +267,7 @@ export const serializeAws_restJson1DeleteApiCacheCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1DeleteApiKeyCommand = async (input, context) => {
+export const se_DeleteApiKeyCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/apikeys/{id}";
@@ -296,7 +284,7 @@ export const serializeAws_restJson1DeleteApiKeyCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1DeleteDataSourceCommand = async (input, context) => {
+export const se_DeleteDataSourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/datasources/{name}";
@@ -313,7 +301,7 @@ export const serializeAws_restJson1DeleteDataSourceCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1DeleteDomainNameCommand = async (input, context) => {
+export const se_DeleteDomainNameCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/domainnames/{domainName}";
@@ -329,7 +317,7 @@ export const serializeAws_restJson1DeleteDomainNameCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1DeleteFunctionCommand = async (input, context) => {
+export const se_DeleteFunctionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/functions/{functionId}";
@@ -346,7 +334,7 @@ export const serializeAws_restJson1DeleteFunctionCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1DeleteGraphqlApiCommand = async (input, context) => {
+export const se_DeleteGraphqlApiCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}";
@@ -362,7 +350,7 @@ export const serializeAws_restJson1DeleteGraphqlApiCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1DeleteResolverCommand = async (input, context) => {
+export const se_DeleteResolverCommand = 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 +369,7 @@ export const serializeAws_restJson1DeleteResolverCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1DeleteTypeCommand = async (input, context) => {
+export const se_DeleteTypeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/types/{typeName}";
@@ -398,7 +386,7 @@ export const serializeAws_restJson1DeleteTypeCommand = async (input, context) =>
         body,
     });
 };
-export const serializeAws_restJson1DisassociateApiCommand = async (input, context) => {
+export const se_DisassociateApiCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -415,7 +403,7 @@ export const serializeAws_restJson1DisassociateApiCommand = async (input, contex
         body,
     });
 };
-export const serializeAws_restJson1EvaluateCodeCommand = async (input, context) => {
+export const se_EvaluateCodeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -426,7 +414,7 @@ export const serializeAws_restJson1EvaluateCodeCommand = async (input, context)
         ...(input.code != null && { code: input.code }),
         ...(input.context != null && { context: input.context }),
         ...(input.function != null && { function: input.function }),
-        ...(input.runtime != null && { runtime: serializeAws_restJson1AppSyncRuntime(input.runtime, context) }),
+        ...(input.runtime != null && { runtime: se_AppSyncRuntime(input.runtime, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -438,7 +426,7 @@ export const serializeAws_restJson1EvaluateCodeCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1EvaluateMappingTemplateCommand = async (input, context) => {
+export const se_EvaluateMappingTemplateCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -459,7 +447,7 @@ export const serializeAws_restJson1EvaluateMappingTemplateCommand = async (input
         body,
     });
 };
-export const serializeAws_restJson1FlushApiCacheCommand = async (input, context) => {
+export const se_FlushApiCacheCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/FlushCache";
@@ -475,7 +463,7 @@ export const serializeAws_restJson1FlushApiCacheCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1GetApiAssociationCommand = async (input, context) => {
+export const se_GetApiAssociationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -492,7 +480,7 @@ export const serializeAws_restJson1GetApiAssociationCommand = async (input, cont
         body,
     });
 };
-export const serializeAws_restJson1GetApiCacheCommand = async (input, context) => {
+export const se_GetApiCacheCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/ApiCaches";
@@ -508,7 +496,7 @@ export const serializeAws_restJson1GetApiCacheCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1GetDataSourceCommand = async (input, context) => {
+export const se_GetDataSourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/datasources/{name}";
@@ -525,7 +513,7 @@ export const serializeAws_restJson1GetDataSourceCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1GetDomainNameCommand = async (input, context) => {
+export const se_GetDomainNameCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/domainnames/{domainName}";
@@ -541,7 +529,7 @@ export const serializeAws_restJson1GetDomainNameCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1GetFunctionCommand = async (input, context) => {
+export const se_GetFunctionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/functions/{functionId}";
@@ -558,7 +546,7 @@ export const serializeAws_restJson1GetFunctionCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1GetGraphqlApiCommand = async (input, context) => {
+export const se_GetGraphqlApiCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}";
@@ -574,7 +562,7 @@ export const serializeAws_restJson1GetGraphqlApiCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1GetIntrospectionSchemaCommand = async (input, context) => {
+export const se_GetIntrospectionSchemaCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/schema";
@@ -595,7 +583,7 @@ export const serializeAws_restJson1GetIntrospectionSchemaCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1GetResolverCommand = async (input, context) => {
+export const se_GetResolverCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -614,7 +602,7 @@ export const serializeAws_restJson1GetResolverCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1GetSchemaCreationStatusCommand = async (input, context) => {
+export const se_GetSchemaCreationStatusCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/schemacreation";
@@ -630,7 +618,7 @@ export const serializeAws_restJson1GetSchemaCreationStatusCommand = async (input
         body,
     });
 };
-export const serializeAws_restJson1GetTypeCommand = async (input, context) => {
+export const se_GetTypeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/types/{typeName}";
@@ -651,7 +639,7 @@ export const serializeAws_restJson1GetTypeCommand = async (input, context) => {
         body,
     });
 };
-export const serializeAws_restJson1ListApiKeysCommand = async (input, context) => {
+export const se_ListApiKeysCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/apikeys";
@@ -672,7 +660,7 @@ export const serializeAws_restJson1ListApiKeysCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1ListDataSourcesCommand = async (input, context) => {
+export const se_ListDataSourcesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/datasources";
@@ -693,7 +681,7 @@ export const serializeAws_restJson1ListDataSourcesCommand = async (input, contex
         body,
     });
 };
-export const serializeAws_restJson1ListDomainNamesCommand = async (input, context) => {
+export const se_ListDomainNamesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/domainnames";
@@ -713,7 +701,7 @@ export const serializeAws_restJson1ListDomainNamesCommand = async (input, contex
         body,
     });
 };
-export const serializeAws_restJson1ListFunctionsCommand = async (input, context) => {
+export const se_ListFunctionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/functions";
@@ -734,7 +722,7 @@ export const serializeAws_restJson1ListFunctionsCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1ListGraphqlApisCommand = async (input, context) => {
+export const se_ListGraphqlApisCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis";
@@ -754,7 +742,7 @@ export const serializeAws_restJson1ListGraphqlApisCommand = async (input, contex
         body,
     });
 };
-export const serializeAws_restJson1ListResolversCommand = async (input, context) => {
+export const se_ListResolversCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -777,7 +765,7 @@ export const serializeAws_restJson1ListResolversCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1ListResolversByFunctionCommand = async (input, context) => {
+export const se_ListResolversByFunctionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -800,7 +788,7 @@ export const serializeAws_restJson1ListResolversByFunctionCommand = async (input
         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 || ""}` + "/v1/tags/{resourceArn}";
@@ -816,7 +804,7 @@ export const serializeAws_restJson1ListTagsForResourceCommand = async (input, co
         body,
     });
 };
-export const serializeAws_restJson1ListTypesCommand = async (input, context) => {
+export const se_ListTypesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/types";
@@ -838,7 +826,7 @@ export const serializeAws_restJson1ListTypesCommand = async (input, context) =>
         body,
     });
 };
-export const serializeAws_restJson1StartSchemaCreationCommand = async (input, context) => {
+export const se_StartSchemaCreationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -859,7 +847,7 @@ export const serializeAws_restJson1StartSchemaCreationCommand = 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",
@@ -868,7 +856,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,
@@ -880,7 +868,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 || ""}` + "/v1/tags/{resourceArn}";
@@ -903,7 +891,7 @@ export const serializeAws_restJson1UntagResourceCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1UpdateApiCacheCommand = async (input, context) => {
+export const se_UpdateApiCacheCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -926,7 +914,7 @@ export const serializeAws_restJson1UpdateApiCacheCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1UpdateApiKeyCommand = async (input, context) => {
+export const se_UpdateApiKeyCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -949,7 +937,7 @@ export const serializeAws_restJson1UpdateApiKeyCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1UpdateDataSourceCommand = async (input, context) => {
+export const se_UpdateDataSourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -960,26 +948,20 @@ export const serializeAws_restJson1UpdateDataSourceCommand = async (input, conte
     let body;
     body = JSON.stringify({
         ...(input.description != null && { description: input.description }),
-        ...(input.dynamodbConfig != null && {
-            dynamodbConfig: serializeAws_restJson1DynamodbDataSourceConfig(input.dynamodbConfig, context),
-        }),
+        ...(input.dynamodbConfig != null && { dynamodbConfig: se_DynamodbDataSourceConfig(input.dynamodbConfig, context) }),
         ...(input.elasticsearchConfig != null && {
-            elasticsearchConfig: serializeAws_restJson1ElasticsearchDataSourceConfig(input.elasticsearchConfig, context),
+            elasticsearchConfig: se_ElasticsearchDataSourceConfig(input.elasticsearchConfig, context),
         }),
         ...(input.eventBridgeConfig != null && {
-            eventBridgeConfig: serializeAws_restJson1EventBridgeDataSourceConfig(input.eventBridgeConfig, context),
-        }),
-        ...(input.httpConfig != null && {
-            httpConfig: serializeAws_restJson1HttpDataSourceConfig(input.httpConfig, context),
-        }),
-        ...(input.lambdaConfig != null && {
-            lambdaConfig: serializeAws_restJson1LambdaDataSourceConfig(input.lambdaConfig, context),
+            eventBridgeConfig: se_EventBridgeDataSourceConfig(input.eventBridgeConfig, context),
         }),
+        ...(input.httpConfig != null && { httpConfig: se_HttpDataSourceConfig(input.httpConfig, context) }),
+        ...(input.lambdaConfig != null && { lambdaConfig: se_LambdaDataSourceConfig(input.lambdaConfig, context) }),
         ...(input.openSearchServiceConfig != null && {
-            openSearchServiceConfig: serializeAws_restJson1OpenSearchServiceDataSourceConfig(input.openSearchServiceConfig, context),
+            openSearchServiceConfig: se_OpenSearchServiceDataSourceConfig(input.openSearchServiceConfig, context),
         }),
         ...(input.relationalDatabaseConfig != null && {
-            relationalDatabaseConfig: serializeAws_restJson1RelationalDatabaseDataSourceConfig(input.relationalDatabaseConfig, context),
+            relationalDatabaseConfig: se_RelationalDatabaseDataSourceConfig(input.relationalDatabaseConfig, context),
         }),
         ...(input.serviceRoleArn != null && { serviceRoleArn: input.serviceRoleArn }),
         ...(input.type != null && { type: input.type }),
@@ -994,7 +976,7 @@ export const serializeAws_restJson1UpdateDataSourceCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1UpdateDomainNameCommand = async (input, context) => {
+export const se_UpdateDomainNameCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -1015,7 +997,7 @@ export const serializeAws_restJson1UpdateDomainNameCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1UpdateFunctionCommand = async (input, context) => {
+export const se_UpdateFunctionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -1033,8 +1015,8 @@ export const serializeAws_restJson1UpdateFunctionCommand = async (input, context
         ...(input.name != null && { name: input.name }),
         ...(input.requestMappingTemplate != null && { requestMappingTemplate: input.requestMappingTemplate }),
         ...(input.responseMappingTemplate != null && { responseMappingTemplate: input.responseMappingTemplate }),
-        ...(input.runtime != null && { runtime: serializeAws_restJson1AppSyncRuntime(input.runtime, context) }),
-        ...(input.syncConfig != null && { syncConfig: serializeAws_restJson1SyncConfig(input.syncConfig, context) }),
+        ...(input.runtime != null && { runtime: se_AppSyncRuntime(input.runtime, context) }),
+        ...(input.syncConfig != null && { syncConfig: se_SyncConfig(input.syncConfig, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -1046,7 +1028,7 @@ export const serializeAws_restJson1UpdateFunctionCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1UpdateGraphqlApiCommand = async (input, context) => {
+export const se_UpdateGraphqlApiCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -1056,20 +1038,18 @@ export const serializeAws_restJson1UpdateGraphqlApiCommand = async (input, conte
     let body;
     body = JSON.stringify({
         ...(input.additionalAuthenticationProviders != null && {
-            additionalAuthenticationProviders: serializeAws_restJson1AdditionalAuthenticationProviders(input.additionalAuthenticationProviders, context),
+            additionalAuthenticationProviders: se_AdditionalAuthenticationProviders(input.additionalAuthenticationProviders, context),
         }),
         ...(input.authenticationType != null && { authenticationType: input.authenticationType }),
         ...(input.lambdaAuthorizerConfig != null && {
-            lambdaAuthorizerConfig: serializeAws_restJson1LambdaAuthorizerConfig(input.lambdaAuthorizerConfig, context),
+            lambdaAuthorizerConfig: se_LambdaAuthorizerConfig(input.lambdaAuthorizerConfig, context),
         }),
-        ...(input.logConfig != null && { logConfig: serializeAws_restJson1LogConfig(input.logConfig, context) }),
+        ...(input.logConfig != null && { logConfig: se_LogConfig(input.logConfig, context) }),
         ...(input.name != null && { name: input.name }),
         ...(input.openIDConnectConfig != null && {
-            openIDConnectConfig: serializeAws_restJson1OpenIDConnectConfig(input.openIDConnectConfig, context),
-        }),
-        ...(input.userPoolConfig != null && {
-            userPoolConfig: serializeAws_restJson1UserPoolConfig(input.userPoolConfig, context),
+            openIDConnectConfig: se_OpenIDConnectConfig(input.openIDConnectConfig, context),
         }),
+        ...(input.userPoolConfig != null && { userPoolConfig: se_UserPoolConfig(input.userPoolConfig, context) }),
         ...(input.xrayEnabled != null && { xrayEnabled: input.xrayEnabled }),
     });
     return new __HttpRequest({
@@ -1082,7 +1062,7 @@ export const serializeAws_restJson1UpdateGraphqlApiCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1UpdateResolverCommand = async (input, context) => {
+export const se_UpdateResolverCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -1094,20 +1074,16 @@ export const serializeAws_restJson1UpdateResolverCommand = async (input, context
     resolvedPath = __resolvedPath(resolvedPath, input, "fieldName", () => input.fieldName, "{fieldName}", false);
     let body;
     body = JSON.stringify({
-        ...(input.cachingConfig != null && {
-            cachingConfig: serializeAws_restJson1CachingConfig(input.cachingConfig, context),
-        }),
+        ...(input.cachingConfig != null && { cachingConfig: se_CachingConfig(input.cachingConfig, context) }),
         ...(input.code != null && { code: input.code }),
         ...(input.dataSourceName != null && { dataSourceName: input.dataSourceName }),
         ...(input.kind != null && { kind: input.kind }),
         ...(input.maxBatchSize != null && { maxBatchSize: input.maxBatchSize }),
-        ...(input.pipelineConfig != null && {
-            pipelineConfig: serializeAws_restJson1PipelineConfig(input.pipelineConfig, context),
-        }),
+        ...(input.pipelineConfig != null && { pipelineConfig: se_PipelineConfig(input.pipelineConfig, context) }),
         ...(input.requestMappingTemplate != null && { requestMappingTemplate: input.requestMappingTemplate }),
         ...(input.responseMappingTemplate != null && { responseMappingTemplate: input.responseMappingTemplate }),
-        ...(input.runtime != null && { runtime: serializeAws_restJson1AppSyncRuntime(input.runtime, context) }),
-        ...(input.syncConfig != null && { syncConfig: serializeAws_restJson1SyncConfig(input.syncConfig, context) }),
+        ...(input.runtime != null && { runtime: se_AppSyncRuntime(input.runtime, context) }),
+        ...(input.syncConfig != null && { syncConfig: se_SyncConfig(input.syncConfig, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -1119,7 +1095,7 @@ export const serializeAws_restJson1UpdateResolverCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1UpdateTypeCommand = async (input, context) => {
+export const se_UpdateTypeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -1142,20 +1118,20 @@ export const serializeAws_restJson1UpdateTypeCommand = async (input, context) =>
         body,
     });
 };
-export const deserializeAws_restJson1AssociateApiCommand = async (output, context) => {
+export const de_AssociateApiCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1AssociateApiCommandError(output, context);
+        return de_AssociateApiCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.apiAssociation != null) {
-        contents.apiAssociation = deserializeAws_restJson1ApiAssociation(data.apiAssociation, context);
+        contents.apiAssociation = de_ApiAssociation(data.apiAssociation, context);
     }
     return contents;
 };
-const deserializeAws_restJson1AssociateApiCommandError = async (output, context) => {
+const de_AssociateApiCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1164,16 +1140,16 @@ const deserializeAws_restJson1AssociateApiCommandError = async (output, context)
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.appsync#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1184,20 +1160,20 @@ const deserializeAws_restJson1AssociateApiCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1CreateApiCacheCommand = async (output, context) => {
+export const de_CreateApiCacheCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateApiCacheCommandError(output, context);
+        return de_CreateApiCacheCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.apiCache != null) {
-        contents.apiCache = deserializeAws_restJson1ApiCache(data.apiCache, context);
+        contents.apiCache = de_ApiCache(data.apiCache, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateApiCacheCommandError = async (output, context) => {
+const de_CreateApiCacheCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1206,19 +1182,19 @@ const deserializeAws_restJson1CreateApiCacheCommandError = async (output, contex
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1229,20 +1205,20 @@ const deserializeAws_restJson1CreateApiCacheCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1CreateApiKeyCommand = async (output, context) => {
+export const de_CreateApiKeyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateApiKeyCommandError(output, context);
+        return de_CreateApiKeyCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.apiKey != null) {
-        contents.apiKey = deserializeAws_restJson1ApiKey(data.apiKey, context);
+        contents.apiKey = de_ApiKey(data.apiKey, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateApiKeyCommandError = async (output, context) => {
+const de_CreateApiKeyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1251,25 +1227,25 @@ const deserializeAws_restJson1CreateApiKeyCommandError = async (output, context)
     switch (errorCode) {
         case "ApiKeyLimitExceededException":
         case "com.amazonaws.appsync#ApiKeyLimitExceededException":
-            throw await deserializeAws_restJson1ApiKeyLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_ApiKeyLimitExceededExceptionRes(parsedOutput, context);
         case "ApiKeyValidityOutOfBoundsException":
         case "com.amazonaws.appsync#ApiKeyValidityOutOfBoundsException":
-            throw await deserializeAws_restJson1ApiKeyValidityOutOfBoundsExceptionResponse(parsedOutput, context);
+            throw await de_ApiKeyValidityOutOfBoundsExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.appsync#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1280,20 +1256,20 @@ const deserializeAws_restJson1CreateApiKeyCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1CreateDataSourceCommand = async (output, context) => {
+export const de_CreateDataSourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateDataSourceCommandError(output, context);
+        return de_CreateDataSourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.dataSource != null) {
-        contents.dataSource = deserializeAws_restJson1DataSource(data.dataSource, context);
+        contents.dataSource = de_DataSource(data.dataSource, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateDataSourceCommandError = async (output, context) => {
+const de_CreateDataSourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1302,19 +1278,19 @@ const deserializeAws_restJson1CreateDataSourceCommandError = async (output, cont
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1325,20 +1301,20 @@ const deserializeAws_restJson1CreateDataSourceCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1CreateDomainNameCommand = async (output, context) => {
+export const de_CreateDomainNameCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateDomainNameCommandError(output, context);
+        return de_CreateDomainNameCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.domainNameConfig != null) {
-        contents.domainNameConfig = deserializeAws_restJson1DomainNameConfig(data.domainNameConfig, context);
+        contents.domainNameConfig = de_DomainNameConfig(data.domainNameConfig, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateDomainNameCommandError = async (output, context) => {
+const de_CreateDomainNameCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1347,13 +1323,13 @@ const deserializeAws_restJson1CreateDomainNameCommandError = async (output, cont
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.appsync#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1364,20 +1340,20 @@ const deserializeAws_restJson1CreateDomainNameCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1CreateFunctionCommand = async (output, context) => {
+export const de_CreateFunctionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateFunctionCommandError(output, context);
+        return de_CreateFunctionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.functionConfiguration != null) {
-        contents.functionConfiguration = deserializeAws_restJson1FunctionConfiguration(data.functionConfiguration, context);
+        contents.functionConfiguration = de_FunctionConfiguration(data.functionConfiguration, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateFunctionCommandError = async (output, context) => {
+const de_CreateFunctionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1386,16 +1362,16 @@ const deserializeAws_restJson1CreateFunctionCommandError = async (output, contex
     switch (errorCode) {
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1406,20 +1382,20 @@ const deserializeAws_restJson1CreateFunctionCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1CreateGraphqlApiCommand = async (output, context) => {
+export const de_CreateGraphqlApiCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateGraphqlApiCommandError(output, context);
+        return de_CreateGraphqlApiCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.graphqlApi != null) {
-        contents.graphqlApi = deserializeAws_restJson1GraphqlApi(data.graphqlApi, context);
+        contents.graphqlApi = de_GraphqlApi(data.graphqlApi, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateGraphqlApiCommandError = async (output, context) => {
+const de_CreateGraphqlApiCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1428,22 +1404,22 @@ const deserializeAws_restJson1CreateGraphqlApiCommandError = async (output, cont
     switch (errorCode) {
         case "ApiLimitExceededException":
         case "com.amazonaws.appsync#ApiLimitExceededException":
-            throw await deserializeAws_restJson1ApiLimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_ApiLimitExceededExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.appsync#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1454,20 +1430,20 @@ const deserializeAws_restJson1CreateGraphqlApiCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1CreateResolverCommand = async (output, context) => {
+export const de_CreateResolverCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateResolverCommandError(output, context);
+        return de_CreateResolverCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.resolver != null) {
-        contents.resolver = deserializeAws_restJson1Resolver(data.resolver, context);
+        contents.resolver = de_Resolver(data.resolver, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateResolverCommandError = async (output, context) => {
+const de_CreateResolverCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1476,19 +1452,19 @@ const deserializeAws_restJson1CreateResolverCommandError = async (output, contex
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1499,20 +1475,20 @@ const deserializeAws_restJson1CreateResolverCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1CreateTypeCommand = async (output, context) => {
+export const de_CreateTypeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateTypeCommandError(output, context);
+        return de_CreateTypeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.type != null) {
-        contents.type = deserializeAws_restJson1Type(data.type, context);
+        contents.type = de_Type(data.type, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateTypeCommandError = async (output, context) => {
+const de_CreateTypeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1521,19 +1497,19 @@ const deserializeAws_restJson1CreateTypeCommandError = async (output, context) =
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1544,9 +1520,9 @@ const deserializeAws_restJson1CreateTypeCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_restJson1DeleteApiCacheCommand = async (output, context) => {
+export const de_DeleteApiCacheCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteApiCacheCommandError(output, context);
+        return de_DeleteApiCacheCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1554,7 +1530,7 @@ export const deserializeAws_restJson1DeleteApiCacheCommand = async (output, cont
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteApiCacheCommandError = async (output, context) => {
+const de_DeleteApiCacheCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1563,19 +1539,19 @@ const deserializeAws_restJson1DeleteApiCacheCommandError = async (output, contex
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1586,9 +1562,9 @@ const deserializeAws_restJson1DeleteApiCacheCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1DeleteApiKeyCommand = async (output, context) => {
+export const de_DeleteApiKeyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteApiKeyCommandError(output, context);
+        return de_DeleteApiKeyCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1596,7 +1572,7 @@ export const deserializeAws_restJson1DeleteApiKeyCommand = async (output, contex
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteApiKeyCommandError = async (output, context) => {
+const de_DeleteApiKeyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1605,16 +1581,16 @@ const deserializeAws_restJson1DeleteApiKeyCommandError = async (output, context)
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1625,9 +1601,9 @@ const deserializeAws_restJson1DeleteApiKeyCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1DeleteDataSourceCommand = async (output, context) => {
+export const de_DeleteDataSourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteDataSourceCommandError(output, context);
+        return de_DeleteDataSourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1635,7 +1611,7 @@ export const deserializeAws_restJson1DeleteDataSourceCommand = async (output, co
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteDataSourceCommandError = async (output, context) => {
+const de_DeleteDataSourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1644,19 +1620,19 @@ const deserializeAws_restJson1DeleteDataSourceCommandError = async (output, cont
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1667,9 +1643,9 @@ const deserializeAws_restJson1DeleteDataSourceCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1DeleteDomainNameCommand = async (output, context) => {
+export const de_DeleteDomainNameCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteDomainNameCommandError(output, context);
+        return de_DeleteDomainNameCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1677,7 +1653,7 @@ export const deserializeAws_restJson1DeleteDomainNameCommand = async (output, co
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteDomainNameCommandError = async (output, context) => {
+const de_DeleteDomainNameCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1686,19 +1662,19 @@ const deserializeAws_restJson1DeleteDomainNameCommandError = async (output, cont
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.appsync#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1709,9 +1685,9 @@ const deserializeAws_restJson1DeleteDomainNameCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1DeleteFunctionCommand = async (output, context) => {
+export const de_DeleteFunctionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteFunctionCommandError(output, context);
+        return de_DeleteFunctionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1719,7 +1695,7 @@ export const deserializeAws_restJson1DeleteFunctionCommand = async (output, cont
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteFunctionCommandError = async (output, context) => {
+const de_DeleteFunctionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1728,16 +1704,16 @@ const deserializeAws_restJson1DeleteFunctionCommandError = async (output, contex
     switch (errorCode) {
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1748,9 +1724,9 @@ const deserializeAws_restJson1DeleteFunctionCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1DeleteGraphqlApiCommand = async (output, context) => {
+export const de_DeleteGraphqlApiCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteGraphqlApiCommandError(output, context);
+        return de_DeleteGraphqlApiCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1758,7 +1734,7 @@ export const deserializeAws_restJson1DeleteGraphqlApiCommand = async (output, co
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteGraphqlApiCommandError = async (output, context) => {
+const de_DeleteGraphqlApiCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1767,22 +1743,22 @@ const deserializeAws_restJson1DeleteGraphqlApiCommandError = async (output, cont
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.appsync#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1793,9 +1769,9 @@ const deserializeAws_restJson1DeleteGraphqlApiCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1DeleteResolverCommand = async (output, context) => {
+export const de_DeleteResolverCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteResolverCommandError(output, context);
+        return de_DeleteResolverCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1803,7 +1779,7 @@ export const deserializeAws_restJson1DeleteResolverCommand = async (output, cont
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteResolverCommandError = async (output, context) => {
+const de_DeleteResolverCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1812,19 +1788,19 @@ const deserializeAws_restJson1DeleteResolverCommandError = async (output, contex
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1835,9 +1811,9 @@ const deserializeAws_restJson1DeleteResolverCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1DeleteTypeCommand = async (output, context) => {
+export const de_DeleteTypeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteTypeCommandError(output, context);
+        return de_DeleteTypeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1845,7 +1821,7 @@ export const deserializeAws_restJson1DeleteTypeCommand = async (output, context)
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteTypeCommandError = async (output, context) => {
+const de_DeleteTypeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1854,19 +1830,19 @@ const deserializeAws_restJson1DeleteTypeCommandError = async (output, context) =
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1877,9 +1853,9 @@ const deserializeAws_restJson1DeleteTypeCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_restJson1DisassociateApiCommand = async (output, context) => {
+export const de_DisassociateApiCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DisassociateApiCommandError(output, context);
+        return de_DisassociateApiCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1887,7 +1863,7 @@ export const deserializeAws_restJson1DisassociateApiCommand = async (output, con
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DisassociateApiCommandError = async (output, context) => {
+const de_DisassociateApiCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1896,19 +1872,19 @@ const deserializeAws_restJson1DisassociateApiCommandError = async (output, conte
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.appsync#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1919,26 +1895,26 @@ const deserializeAws_restJson1DisassociateApiCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_restJson1EvaluateCodeCommand = async (output, context) => {
+export const de_EvaluateCodeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1EvaluateCodeCommandError(output, context);
+        return de_EvaluateCodeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.error != null) {
-        contents.error = deserializeAws_restJson1EvaluateCodeErrorDetail(data.error, context);
+        contents.error = de_EvaluateCodeErrorDetail(data.error, context);
     }
     if (data.evaluationResult != null) {
         contents.evaluationResult = __expectString(data.evaluationResult);
     }
     if (data.logs != null) {
-        contents.logs = deserializeAws_restJson1Logs(data.logs, context);
+        contents.logs = de_Logs(data.logs, context);
     }
     return contents;
 };
-const deserializeAws_restJson1EvaluateCodeCommandError = async (output, context) => {
+const de_EvaluateCodeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1947,13 +1923,13 @@ const deserializeAws_restJson1EvaluateCodeCommandError = async (output, context)
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.appsync#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1964,26 +1940,26 @@ const deserializeAws_restJson1EvaluateCodeCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1EvaluateMappingTemplateCommand = async (output, context) => {
+export const de_EvaluateMappingTemplateCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1EvaluateMappingTemplateCommandError(output, context);
+        return de_EvaluateMappingTemplateCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.error != null) {
-        contents.error = deserializeAws_restJson1ErrorDetail(data.error, context);
+        contents.error = de_ErrorDetail(data.error, context);
     }
     if (data.evaluationResult != null) {
         contents.evaluationResult = __expectString(data.evaluationResult);
     }
     if (data.logs != null) {
-        contents.logs = deserializeAws_restJson1Logs(data.logs, context);
+        contents.logs = de_Logs(data.logs, context);
     }
     return contents;
 };
-const deserializeAws_restJson1EvaluateMappingTemplateCommandError = async (output, context) => {
+const de_EvaluateMappingTemplateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1992,13 +1968,13 @@ const deserializeAws_restJson1EvaluateMappingTemplateCommandError = async (outpu
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.appsync#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2009,9 +1985,9 @@ const deserializeAws_restJson1EvaluateMappingTemplateCommandError = async (outpu
             });
     }
 };
-export const deserializeAws_restJson1FlushApiCacheCommand = async (output, context) => {
+export const de_FlushApiCacheCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1FlushApiCacheCommandError(output, context);
+        return de_FlushApiCacheCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2019,7 +1995,7 @@ export const deserializeAws_restJson1FlushApiCacheCommand = async (output, conte
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1FlushApiCacheCommandError = async (output, context) => {
+const de_FlushApiCacheCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2028,19 +2004,19 @@ const deserializeAws_restJson1FlushApiCacheCommandError = async (output, context
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2051,20 +2027,20 @@ const deserializeAws_restJson1FlushApiCacheCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1GetApiAssociationCommand = async (output, context) => {
+export const de_GetApiAssociationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetApiAssociationCommandError(output, context);
+        return de_GetApiAssociationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.apiAssociation != null) {
-        contents.apiAssociation = deserializeAws_restJson1ApiAssociation(data.apiAssociation, context);
+        contents.apiAssociation = de_ApiAssociation(data.apiAssociation, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetApiAssociationCommandError = async (output, context) => {
+const de_GetApiAssociationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2073,16 +2049,16 @@ const deserializeAws_restJson1GetApiAssociationCommandError = async (output, con
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.appsync#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2093,20 +2069,20 @@ const deserializeAws_restJson1GetApiAssociationCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1GetApiCacheCommand = async (output, context) => {
+export const de_GetApiCacheCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetApiCacheCommandError(output, context);
+        return de_GetApiCacheCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.apiCache != null) {
-        contents.apiCache = deserializeAws_restJson1ApiCache(data.apiCache, context);
+        contents.apiCache = de_ApiCache(data.apiCache, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetApiCacheCommandError = async (output, context) => {
+const de_GetApiCacheCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2115,19 +2091,19 @@ const deserializeAws_restJson1GetApiCacheCommandError = async (output, context)
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2138,20 +2114,20 @@ const deserializeAws_restJson1GetApiCacheCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1GetDataSourceCommand = async (output, context) => {
+export const de_GetDataSourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetDataSourceCommandError(output, context);
+        return de_GetDataSourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.dataSource != null) {
-        contents.dataSource = deserializeAws_restJson1DataSource(data.dataSource, context);
+        contents.dataSource = de_DataSource(data.dataSource, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetDataSourceCommandError = async (output, context) => {
+const de_GetDataSourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2160,19 +2136,19 @@ const deserializeAws_restJson1GetDataSourceCommandError = async (output, context
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2183,20 +2159,20 @@ const deserializeAws_restJson1GetDataSourceCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1GetDomainNameCommand = async (output, context) => {
+export const de_GetDomainNameCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetDomainNameCommandError(output, context);
+        return de_GetDomainNameCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.domainNameConfig != null) {
-        contents.domainNameConfig = deserializeAws_restJson1DomainNameConfig(data.domainNameConfig, context);
+        contents.domainNameConfig = de_DomainNameConfig(data.domainNameConfig, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetDomainNameCommandError = async (output, context) => {
+const de_GetDomainNameCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2205,16 +2181,16 @@ const deserializeAws_restJson1GetDomainNameCommandError = async (output, context
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.appsync#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2225,20 +2201,20 @@ const deserializeAws_restJson1GetDomainNameCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1GetFunctionCommand = async (output, context) => {
+export const de_GetFunctionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetFunctionCommandError(output, context);
+        return de_GetFunctionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.functionConfiguration != null) {
-        contents.functionConfiguration = deserializeAws_restJson1FunctionConfiguration(data.functionConfiguration, context);
+        contents.functionConfiguration = de_FunctionConfiguration(data.functionConfiguration, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetFunctionCommandError = async (output, context) => {
+const de_GetFunctionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2247,13 +2223,13 @@ const deserializeAws_restJson1GetFunctionCommandError = async (output, context)
     switch (errorCode) {
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2264,20 +2240,20 @@ const deserializeAws_restJson1GetFunctionCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1GetGraphqlApiCommand = async (output, context) => {
+export const de_GetGraphqlApiCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetGraphqlApiCommandError(output, context);
+        return de_GetGraphqlApiCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.graphqlApi != null) {
-        contents.graphqlApi = deserializeAws_restJson1GraphqlApi(data.graphqlApi, context);
+        contents.graphqlApi = de_GraphqlApi(data.graphqlApi, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetGraphqlApiCommandError = async (output, context) => {
+const de_GetGraphqlApiCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2286,19 +2262,19 @@ const deserializeAws_restJson1GetGraphqlApiCommandError = async (output, context
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.appsync#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2309,9 +2285,9 @@ const deserializeAws_restJson1GetGraphqlApiCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1GetIntrospectionSchemaCommand = async (output, context) => {
+export const de_GetIntrospectionSchemaCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetIntrospectionSchemaCommandError(output, context);
+        return de_GetIntrospectionSchemaCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2320,7 +2296,7 @@ export const deserializeAws_restJson1GetIntrospectionSchemaCommand = async (outp
     contents.schema = data;
     return contents;
 };
-const deserializeAws_restJson1GetIntrospectionSchemaCommandError = async (output, context) => {
+const de_GetIntrospectionSchemaCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2329,16 +2305,16 @@ const deserializeAws_restJson1GetIntrospectionSchemaCommandError = async (output
     switch (errorCode) {
         case "GraphQLSchemaException":
         case "com.amazonaws.appsync#GraphQLSchemaException":
-            throw await deserializeAws_restJson1GraphQLSchemaExceptionResponse(parsedOutput, context);
+            throw await de_GraphQLSchemaExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2349,20 +2325,20 @@ const deserializeAws_restJson1GetIntrospectionSchemaCommandError = async (output
             });
     }
 };
-export const deserializeAws_restJson1GetResolverCommand = async (output, context) => {
+export const de_GetResolverCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetResolverCommandError(output, context);
+        return de_GetResolverCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.resolver != null) {
-        contents.resolver = deserializeAws_restJson1Resolver(data.resolver, context);
+        contents.resolver = de_Resolver(data.resolver, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetResolverCommandError = async (output, context) => {
+const de_GetResolverCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2371,13 +2347,13 @@ const deserializeAws_restJson1GetResolverCommandError = async (output, context)
     switch (errorCode) {
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2388,9 +2364,9 @@ const deserializeAws_restJson1GetResolverCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1GetSchemaCreationStatusCommand = async (output, context) => {
+export const de_GetSchemaCreationStatusCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetSchemaCreationStatusCommandError(output, context);
+        return de_GetSchemaCreationStatusCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2404,7 +2380,7 @@ export const deserializeAws_restJson1GetSchemaCreationStatusCommand = async (out
     }
     return contents;
 };
-const deserializeAws_restJson1GetSchemaCreationStatusCommandError = async (output, context) => {
+const de_GetSchemaCreationStatusCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2413,16 +2389,16 @@ const deserializeAws_restJson1GetSchemaCreationStatusCommandError = async (outpu
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2433,20 +2409,20 @@ const deserializeAws_restJson1GetSchemaCreationStatusCommandError = async (outpu
             });
     }
 };
-export const deserializeAws_restJson1GetTypeCommand = async (output, context) => {
+export const de_GetTypeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetTypeCommandError(output, context);
+        return de_GetTypeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.type != null) {
-        contents.type = deserializeAws_restJson1Type(data.type, context);
+        contents.type = de_Type(data.type, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetTypeCommandError = async (output, context) => {
+const de_GetTypeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2455,19 +2431,19 @@ const deserializeAws_restJson1GetTypeCommandError = async (output, context) => {
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2478,23 +2454,23 @@ const deserializeAws_restJson1GetTypeCommandError = async (output, context) => {
             });
     }
 };
-export const deserializeAws_restJson1ListApiKeysCommand = async (output, context) => {
+export const de_ListApiKeysCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListApiKeysCommandError(output, context);
+        return de_ListApiKeysCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.apiKeys != null) {
-        contents.apiKeys = deserializeAws_restJson1ApiKeys(data.apiKeys, context);
+        contents.apiKeys = de_ApiKeys(data.apiKeys, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListApiKeysCommandError = async (output, context) => {
+const de_ListApiKeysCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2503,16 +2479,16 @@ const deserializeAws_restJson1ListApiKeysCommandError = async (output, context)
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2523,23 +2499,23 @@ const deserializeAws_restJson1ListApiKeysCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1ListDataSourcesCommand = async (output, context) => {
+export const de_ListDataSourcesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListDataSourcesCommandError(output, context);
+        return de_ListDataSourcesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.dataSources != null) {
-        contents.dataSources = deserializeAws_restJson1DataSources(data.dataSources, context);
+        contents.dataSources = de_DataSources(data.dataSources, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListDataSourcesCommandError = async (output, context) => {
+const de_ListDataSourcesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2548,16 +2524,16 @@ const deserializeAws_restJson1ListDataSourcesCommandError = async (output, conte
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2568,23 +2544,23 @@ const deserializeAws_restJson1ListDataSourcesCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_restJson1ListDomainNamesCommand = async (output, context) => {
+export const de_ListDomainNamesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListDomainNamesCommandError(output, context);
+        return de_ListDomainNamesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.domainNameConfigs != null) {
-        contents.domainNameConfigs = deserializeAws_restJson1DomainNameConfigs(data.domainNameConfigs, context);
+        contents.domainNameConfigs = de_DomainNameConfigs(data.domainNameConfigs, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListDomainNamesCommandError = async (output, context) => {
+const de_ListDomainNamesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2593,13 +2569,13 @@ const deserializeAws_restJson1ListDomainNamesCommandError = async (output, conte
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.appsync#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2610,23 +2586,23 @@ const deserializeAws_restJson1ListDomainNamesCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_restJson1ListFunctionsCommand = async (output, context) => {
+export const de_ListFunctionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListFunctionsCommandError(output, context);
+        return de_ListFunctionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.functions != null) {
-        contents.functions = deserializeAws_restJson1Functions(data.functions, context);
+        contents.functions = de_Functions(data.functions, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListFunctionsCommandError = async (output, context) => {
+const de_ListFunctionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2635,16 +2611,16 @@ const deserializeAws_restJson1ListFunctionsCommandError = async (output, context
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2655,23 +2631,23 @@ const deserializeAws_restJson1ListFunctionsCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1ListGraphqlApisCommand = async (output, context) => {
+export const de_ListGraphqlApisCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListGraphqlApisCommandError(output, context);
+        return de_ListGraphqlApisCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.graphqlApis != null) {
-        contents.graphqlApis = deserializeAws_restJson1GraphqlApis(data.graphqlApis, context);
+        contents.graphqlApis = de_GraphqlApis(data.graphqlApis, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1ListGraphqlApisCommandError = async (output, context) => {
+const de_ListGraphqlApisCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2680,13 +2656,13 @@ const deserializeAws_restJson1ListGraphqlApisCommandError = async (output, conte
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2697,9 +2673,9 @@ const deserializeAws_restJson1ListGraphqlApisCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_restJson1ListResolversCommand = async (output, context) => {
+export const de_ListResolversCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListResolversCommandError(output, context);
+        return de_ListResolversCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2709,11 +2685,11 @@ export const deserializeAws_restJson1ListResolversCommand = async (output, conte
         contents.nextToken = __expectString(data.nextToken);
     }
     if (data.resolvers != null) {
-        contents.resolvers = deserializeAws_restJson1Resolvers(data.resolvers, context);
+        contents.resolvers = de_Resolvers(data.resolvers, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListResolversCommandError = async (output, context) => {
+const de_ListResolversCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2722,16 +2698,16 @@ const deserializeAws_restJson1ListResolversCommandError = async (output, context
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2742,9 +2718,9 @@ const deserializeAws_restJson1ListResolversCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1ListResolversByFunctionCommand = async (output, context) => {
+export const de_ListResolversByFunctionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListResolversByFunctionCommandError(output, context);
+        return de_ListResolversByFunctionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2754,11 +2730,11 @@ export const deserializeAws_restJson1ListResolversByFunctionCommand = async (out
         contents.nextToken = __expectString(data.nextToken);
     }
     if (data.resolvers != null) {
-        contents.resolvers = deserializeAws_restJson1Resolvers(data.resolvers, context);
+        contents.resolvers = de_Resolvers(data.resolvers, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListResolversByFunctionCommandError = async (output, context) => {
+const de_ListResolversByFunctionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2767,16 +2743,16 @@ const deserializeAws_restJson1ListResolversByFunctionCommandError = async (outpu
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2787,20 +2763,20 @@ const deserializeAws_restJson1ListResolversByFunctionCommandError = async (outpu
             });
     }
 };
-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),
@@ -2809,22 +2785,22 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.appsync#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.appsync#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2835,9 +2811,9 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_restJson1ListTypesCommand = async (output, context) => {
+export const de_ListTypesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListTypesCommandError(output, context);
+        return de_ListTypesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2847,11 +2823,11 @@ export const deserializeAws_restJson1ListTypesCommand = async (output, context)
         contents.nextToken = __expectString(data.nextToken);
     }
     if (data.types != null) {
-        contents.types = deserializeAws_restJson1TypeList(data.types, context);
+        contents.types = de_TypeList(data.types, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListTypesCommandError = async (output, context) => {
+const de_ListTypesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2860,19 +2836,19 @@ const deserializeAws_restJson1ListTypesCommandError = async (output, context) =>
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2883,9 +2859,9 @@ const deserializeAws_restJson1ListTypesCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_restJson1StartSchemaCreationCommand = async (output, context) => {
+export const de_StartSchemaCreationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1StartSchemaCreationCommandError(output, context);
+        return de_StartSchemaCreationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2896,7 +2872,7 @@ export const deserializeAws_restJson1StartSchemaCreationCommand = async (output,
     }
     return contents;
 };
-const deserializeAws_restJson1StartSchemaCreationCommandError = async (output, context) => {
+const de_StartSchemaCreationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2905,19 +2881,19 @@ const deserializeAws_restJson1StartSchemaCreationCommandError = async (output, c
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2928,9 +2904,9 @@ const deserializeAws_restJson1StartSchemaCreationCommandError = 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),
@@ -2938,7 +2914,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),
@@ -2947,22 +2923,22 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.appsync#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.appsync#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2973,9 +2949,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),
@@ -2983,7 +2959,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),
@@ -2992,22 +2968,22 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.appsync#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.appsync#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -3018,20 +2994,20 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1UpdateApiCacheCommand = async (output, context) => {
+export const de_UpdateApiCacheCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateApiCacheCommandError(output, context);
+        return de_UpdateApiCacheCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.apiCache != null) {
-        contents.apiCache = deserializeAws_restJson1ApiCache(data.apiCache, context);
+        contents.apiCache = de_ApiCache(data.apiCache, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateApiCacheCommandError = async (output, context) => {
+const de_UpdateApiCacheCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3040,19 +3016,19 @@ const deserializeAws_restJson1UpdateApiCacheCommandError = async (output, contex
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -3063,20 +3039,20 @@ const deserializeAws_restJson1UpdateApiCacheCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1UpdateApiKeyCommand = async (output, context) => {
+export const de_UpdateApiKeyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateApiKeyCommandError(output, context);
+        return de_UpdateApiKeyCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.apiKey != null) {
-        contents.apiKey = deserializeAws_restJson1ApiKey(data.apiKey, context);
+        contents.apiKey = de_ApiKey(data.apiKey, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateApiKeyCommandError = async (output, context) => {
+const de_UpdateApiKeyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3085,22 +3061,22 @@ const deserializeAws_restJson1UpdateApiKeyCommandError = async (output, context)
     switch (errorCode) {
         case "ApiKeyValidityOutOfBoundsException":
         case "com.amazonaws.appsync#ApiKeyValidityOutOfBoundsException":
-            throw await deserializeAws_restJson1ApiKeyValidityOutOfBoundsExceptionResponse(parsedOutput, context);
+            throw await de_ApiKeyValidityOutOfBoundsExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.appsync#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -3111,20 +3087,20 @@ const deserializeAws_restJson1UpdateApiKeyCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1UpdateDataSourceCommand = async (output, context) => {
+export const de_UpdateDataSourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateDataSourceCommandError(output, context);
+        return de_UpdateDataSourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.dataSource != null) {
-        contents.dataSource = deserializeAws_restJson1DataSource(data.dataSource, context);
+        contents.dataSource = de_DataSource(data.dataSource, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateDataSourceCommandError = async (output, context) => {
+const de_UpdateDataSourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3133,19 +3109,19 @@ const deserializeAws_restJson1UpdateDataSourceCommandError = async (output, cont
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -3156,20 +3132,20 @@ const deserializeAws_restJson1UpdateDataSourceCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1UpdateDomainNameCommand = async (output, context) => {
+export const de_UpdateDomainNameCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateDomainNameCommandError(output, context);
+        return de_UpdateDomainNameCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.domainNameConfig != null) {
-        contents.domainNameConfig = deserializeAws_restJson1DomainNameConfig(data.domainNameConfig, context);
+        contents.domainNameConfig = de_DomainNameConfig(data.domainNameConfig, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateDomainNameCommandError = async (output, context) => {
+const de_UpdateDomainNameCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3178,19 +3154,19 @@ const deserializeAws_restJson1UpdateDomainNameCommandError = async (output, cont
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.appsync#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -3201,20 +3177,20 @@ const deserializeAws_restJson1UpdateDomainNameCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1UpdateFunctionCommand = async (output, context) => {
+export const de_UpdateFunctionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateFunctionCommandError(output, context);
+        return de_UpdateFunctionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.functionConfiguration != null) {
-        contents.functionConfiguration = deserializeAws_restJson1FunctionConfiguration(data.functionConfiguration, context);
+        contents.functionConfiguration = de_FunctionConfiguration(data.functionConfiguration, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateFunctionCommandError = async (output, context) => {
+const de_UpdateFunctionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3223,16 +3199,16 @@ const deserializeAws_restJson1UpdateFunctionCommandError = async (output, contex
     switch (errorCode) {
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -3243,20 +3219,20 @@ const deserializeAws_restJson1UpdateFunctionCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1UpdateGraphqlApiCommand = async (output, context) => {
+export const de_UpdateGraphqlApiCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateGraphqlApiCommandError(output, context);
+        return de_UpdateGraphqlApiCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.graphqlApi != null) {
-        contents.graphqlApi = deserializeAws_restJson1GraphqlApi(data.graphqlApi, context);
+        contents.graphqlApi = de_GraphqlApi(data.graphqlApi, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateGraphqlApiCommandError = async (output, context) => {
+const de_UpdateGraphqlApiCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3265,22 +3241,22 @@ const deserializeAws_restJson1UpdateGraphqlApiCommandError = async (output, cont
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.appsync#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -3291,20 +3267,20 @@ const deserializeAws_restJson1UpdateGraphqlApiCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1UpdateResolverCommand = async (output, context) => {
+export const de_UpdateResolverCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateResolverCommandError(output, context);
+        return de_UpdateResolverCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.resolver != null) {
-        contents.resolver = deserializeAws_restJson1Resolver(data.resolver, context);
+        contents.resolver = de_Resolver(data.resolver, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateResolverCommandError = async (output, context) => {
+const de_UpdateResolverCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3313,19 +3289,19 @@ const deserializeAws_restJson1UpdateResolverCommandError = async (output, contex
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -3336,20 +3312,20 @@ const deserializeAws_restJson1UpdateResolverCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1UpdateTypeCommand = async (output, context) => {
+export const de_UpdateTypeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateTypeCommandError(output, context);
+        return de_UpdateTypeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.type != null) {
-        contents.type = deserializeAws_restJson1Type(data.type, context);
+        contents.type = de_Type(data.type, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateTypeCommandError = async (output, context) => {
+const de_UpdateTypeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3358,19 +3334,19 @@ const deserializeAws_restJson1UpdateTypeCommandError = async (output, context) =
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.appsync#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.appsync#NotFoundException":
-            throw await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         case "UnauthorizedException":
         case "com.amazonaws.appsync#UnauthorizedException":
-            throw await deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context);
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -3382,7 +3358,7 @@ const deserializeAws_restJson1UpdateTypeCommandError = async (output, context) =
     }
 };
 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) {
@@ -3394,7 +3370,7 @@ const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutpu
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ApiKeyLimitExceededExceptionResponse = async (parsedOutput, context) => {
+const de_ApiKeyLimitExceededExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3406,7 +3382,7 @@ const deserializeAws_restJson1ApiKeyLimitExceededExceptionResponse = async (pars
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ApiKeyValidityOutOfBoundsExceptionResponse = async (parsedOutput, context) => {
+const de_ApiKeyValidityOutOfBoundsExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3418,7 +3394,7 @@ const deserializeAws_restJson1ApiKeyValidityOutOfBoundsExceptionResponse = async
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ApiLimitExceededExceptionResponse = async (parsedOutput, context) => {
+const de_ApiLimitExceededExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3430,11 +3406,11 @@ const deserializeAws_restJson1ApiLimitExceededExceptionResponse = async (parsedO
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput, context) => {
+const de_BadRequestExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.detail != null) {
-        contents.detail = deserializeAws_restJson1BadRequestDetail(data.detail, context);
+        contents.detail = de_BadRequestDetail(data.detail, context);
     }
     if (data.message != null) {
         contents.message = __expectString(data.message);
@@ -3448,7 +3424,7 @@ const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ConcurrentModificationExceptionResponse = async (parsedOutput, context) => {
+const de_ConcurrentModificationExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3460,7 +3436,7 @@ const deserializeAws_restJson1ConcurrentModificationExceptionResponse = async (p
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1GraphQLSchemaExceptionResponse = async (parsedOutput, context) => {
+const de_GraphQLSchemaExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3472,7 +3448,7 @@ const deserializeAws_restJson1GraphQLSchemaExceptionResponse = async (parsedOutp
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1InternalFailureExceptionResponse = async (parsedOutput, context) => {
+const de_InternalFailureExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3484,7 +3460,7 @@ const deserializeAws_restJson1InternalFailureExceptionResponse = async (parsedOu
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1LimitExceededExceptionResponse = async (parsedOutput, context) => {
+const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3496,7 +3472,7 @@ const deserializeAws_restJson1LimitExceededExceptionResponse = async (parsedOutp
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1NotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_NotFoundExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3508,7 +3484,7 @@ const deserializeAws_restJson1NotFoundExceptionResponse = async (parsedOutput, c
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1UnauthorizedExceptionResponse = async (parsedOutput, context) => {
+const de_UnauthorizedExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -3520,112 +3496,106 @@ const deserializeAws_restJson1UnauthorizedExceptionResponse = async (parsedOutpu
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const serializeAws_restJson1AdditionalAuthenticationProvider = (input, context) => {
+const se_AdditionalAuthenticationProvider = (input, context) => {
     return {
         ...(input.authenticationType != null && { authenticationType: input.authenticationType }),
         ...(input.lambdaAuthorizerConfig != null && {
-            lambdaAuthorizerConfig: serializeAws_restJson1LambdaAuthorizerConfig(input.lambdaAuthorizerConfig, context),
+            lambdaAuthorizerConfig: se_LambdaAuthorizerConfig(input.lambdaAuthorizerConfig, context),
         }),
         ...(input.openIDConnectConfig != null && {
-            openIDConnectConfig: serializeAws_restJson1OpenIDConnectConfig(input.openIDConnectConfig, context),
-        }),
-        ...(input.userPoolConfig != null && {
-            userPoolConfig: serializeAws_restJson1CognitoUserPoolConfig(input.userPoolConfig, context),
+            openIDConnectConfig: se_OpenIDConnectConfig(input.openIDConnectConfig, context),
         }),
+        ...(input.userPoolConfig != null && { userPoolConfig: se_CognitoUserPoolConfig(input.userPoolConfig, context) }),
     };
 };
-const serializeAws_restJson1AdditionalAuthenticationProviders = (input, context) => {
+const se_AdditionalAuthenticationProviders = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1AdditionalAuthenticationProvider(entry, context);
+        return se_AdditionalAuthenticationProvider(entry, context);
     });
 };
-const serializeAws_restJson1AppSyncRuntime = (input, context) => {
+const se_AppSyncRuntime = (input, context) => {
     return {
         ...(input.name != null && { name: input.name }),
         ...(input.runtimeVersion != null && { runtimeVersion: input.runtimeVersion }),
     };
 };
-const serializeAws_restJson1AuthorizationConfig = (input, context) => {
+const se_AuthorizationConfig = (input, context) => {
     return {
         ...(input.authorizationType != null && { authorizationType: input.authorizationType }),
-        ...(input.awsIamConfig != null && {
-            awsIamConfig: serializeAws_restJson1AwsIamConfig(input.awsIamConfig, context),
-        }),
+        ...(input.awsIamConfig != null && { awsIamConfig: se_AwsIamConfig(input.awsIamConfig, context) }),
     };
 };
-const serializeAws_restJson1AwsIamConfig = (input, context) => {
+const se_AwsIamConfig = (input, context) => {
     return {
         ...(input.signingRegion != null && { signingRegion: input.signingRegion }),
         ...(input.signingServiceName != null && { signingServiceName: input.signingServiceName }),
     };
 };
-const serializeAws_restJson1CachingConfig = (input, context) => {
+const se_CachingConfig = (input, context) => {
     return {
-        ...(input.cachingKeys != null && { cachingKeys: serializeAws_restJson1CachingKeys(input.cachingKeys, context) }),
+        ...(input.cachingKeys != null && { cachingKeys: se_CachingKeys(input.cachingKeys, context) }),
         ...(input.ttl != null && { ttl: input.ttl }),
     };
 };
-const serializeAws_restJson1CachingKeys = (input, context) => {
+const se_CachingKeys = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1CognitoUserPoolConfig = (input, context) => {
+const se_CognitoUserPoolConfig = (input, context) => {
     return {
         ...(input.appIdClientRegex != null && { appIdClientRegex: input.appIdClientRegex }),
         ...(input.awsRegion != null && { awsRegion: input.awsRegion }),
         ...(input.userPoolId != null && { userPoolId: input.userPoolId }),
     };
 };
-const serializeAws_restJson1DeltaSyncConfig = (input, context) => {
+const se_DeltaSyncConfig = (input, context) => {
     return {
         ...(input.baseTableTTL != null && { baseTableTTL: input.baseTableTTL }),
         ...(input.deltaSyncTableName != null && { deltaSyncTableName: input.deltaSyncTableName }),
         ...(input.deltaSyncTableTTL != null && { deltaSyncTableTTL: input.deltaSyncTableTTL }),
     };
 };
-const serializeAws_restJson1DynamodbDataSourceConfig = (input, context) => {
+const se_DynamodbDataSourceConfig = (input, context) => {
     return {
         ...(input.awsRegion != null && { awsRegion: input.awsRegion }),
-        ...(input.deltaSyncConfig != null && {
-            deltaSyncConfig: serializeAws_restJson1DeltaSyncConfig(input.deltaSyncConfig, context),
-        }),
+        ...(input.deltaSyncConfig != null && { deltaSyncConfig: se_DeltaSyncConfig(input.deltaSyncConfig, context) }),
         ...(input.tableName != null && { tableName: input.tableName }),
         ...(input.useCallerCredentials != null && { useCallerCredentials: input.useCallerCredentials }),
         ...(input.versioned != null && { versioned: input.versioned }),
     };
 };
-const serializeAws_restJson1ElasticsearchDataSourceConfig = (input, context) => {
+const se_ElasticsearchDataSourceConfig = (input, context) => {
     return {
         ...(input.awsRegion != null && { awsRegion: input.awsRegion }),
         ...(input.endpoint != null && { endpoint: input.endpoint }),
     };
 };
-const serializeAws_restJson1EventBridgeDataSourceConfig = (input, context) => {
+const se_EventBridgeDataSourceConfig = (input, context) => {
     return {
         ...(input.eventBusArn != null && { eventBusArn: input.eventBusArn }),
     };
 };
-const serializeAws_restJson1FunctionsIds = (input, context) => {
+const se_FunctionsIds = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1HttpDataSourceConfig = (input, context) => {
+const se_HttpDataSourceConfig = (input, context) => {
     return {
         ...(input.authorizationConfig != null && {
-            authorizationConfig: serializeAws_restJson1AuthorizationConfig(input.authorizationConfig, context),
+            authorizationConfig: se_AuthorizationConfig(input.authorizationConfig, context),
         }),
         ...(input.endpoint != null && { endpoint: input.endpoint }),
     };
 };
-const serializeAws_restJson1LambdaAuthorizerConfig = (input, context) => {
+const se_LambdaAuthorizerConfig = (input, context) => {
     return {
         ...(input.authorizerResultTtlInSeconds != null && {
             authorizerResultTtlInSeconds: input.authorizerResultTtlInSeconds,
@@ -3636,24 +3606,24 @@ const serializeAws_restJson1LambdaAuthorizerConfig = (input, context) => {
         }),
     };
 };
-const serializeAws_restJson1LambdaConflictHandlerConfig = (input, context) => {
+const se_LambdaConflictHandlerConfig = (input, context) => {
     return {
         ...(input.lambdaConflictHandlerArn != null && { lambdaConflictHandlerArn: input.lambdaConflictHandlerArn }),
     };
 };
-const serializeAws_restJson1LambdaDataSourceConfig = (input, context) => {
+const se_LambdaDataSourceConfig = (input, context) => {
     return {
         ...(input.lambdaFunctionArn != null && { lambdaFunctionArn: input.lambdaFunctionArn }),
     };
 };
-const serializeAws_restJson1LogConfig = (input, context) => {
+const se_LogConfig = (input, context) => {
     return {
         ...(input.cloudWatchLogsRoleArn != null && { cloudWatchLogsRoleArn: input.cloudWatchLogsRoleArn }),
         ...(input.excludeVerboseContent != null && { excludeVerboseContent: input.excludeVerboseContent }),
         ...(input.fieldLogLevel != null && { fieldLogLevel: input.fieldLogLevel }),
     };
 };
-const serializeAws_restJson1OpenIDConnectConfig = (input, context) => {
+const se_OpenIDConnectConfig = (input, context) => {
     return {
         ...(input.authTTL != null && { authTTL: input.authTTL }),
         ...(input.clientId != null && { clientId: input.clientId }),
@@ -3661,18 +3631,18 @@ const serializeAws_restJson1OpenIDConnectConfig = (input, context) => {
         ...(input.issuer != null && { issuer: input.issuer }),
     };
 };
-const serializeAws_restJson1OpenSearchServiceDataSourceConfig = (input, context) => {
+const se_OpenSearchServiceDataSourceConfig = (input, context) => {
     return {
         ...(input.awsRegion != null && { awsRegion: input.awsRegion }),
         ...(input.endpoint != null && { endpoint: input.endpoint }),
     };
 };
-const serializeAws_restJson1PipelineConfig = (input, context) => {
+const se_PipelineConfig = (input, context) => {
     return {
-        ...(input.functions != null && { functions: serializeAws_restJson1FunctionsIds(input.functions, context) }),
+        ...(input.functions != null && { functions: se_FunctionsIds(input.functions, context) }),
     };
 };
-const serializeAws_restJson1RdsHttpEndpointConfig = (input, context) => {
+const se_RdsHttpEndpointConfig = (input, context) => {
     return {
         ...(input.awsRegion != null && { awsRegion: input.awsRegion }),
         ...(input.awsSecretStoreArn != null && { awsSecretStoreArn: input.awsSecretStoreArn }),
@@ -3681,26 +3651,26 @@ const serializeAws_restJson1RdsHttpEndpointConfig = (input, context) => {
         ...(input.schema != null && { schema: input.schema }),
     };
 };
-const serializeAws_restJson1RelationalDatabaseDataSourceConfig = (input, context) => {
+const se_RelationalDatabaseDataSourceConfig = (input, context) => {
     return {
         ...(input.rdsHttpEndpointConfig != null && {
-            rdsHttpEndpointConfig: serializeAws_restJson1RdsHttpEndpointConfig(input.rdsHttpEndpointConfig, context),
+            rdsHttpEndpointConfig: se_RdsHttpEndpointConfig(input.rdsHttpEndpointConfig, context),
         }),
         ...(input.relationalDatabaseSourceType != null && {
             relationalDatabaseSourceType: input.relationalDatabaseSourceType,
         }),
     };
 };
-const serializeAws_restJson1SyncConfig = (input, context) => {
+const se_SyncConfig = (input, context) => {
     return {
         ...(input.conflictDetection != null && { conflictDetection: input.conflictDetection }),
         ...(input.conflictHandler != null && { conflictHandler: input.conflictHandler }),
         ...(input.lambdaConflictHandlerConfig != null && {
-            lambdaConflictHandlerConfig: serializeAws_restJson1LambdaConflictHandlerConfig(input.lambdaConflictHandlerConfig, context),
+            lambdaConflictHandlerConfig: se_LambdaConflictHandlerConfig(input.lambdaConflictHandlerConfig, context),
         }),
     };
 };
-const serializeAws_restJson1TagMap = (input, context) => {
+const se_TagMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -3709,7 +3679,7 @@ const serializeAws_restJson1TagMap = (input, context) => {
         return acc;
     }, {});
 };
-const serializeAws_restJson1UserPoolConfig = (input, context) => {
+const se_UserPoolConfig = (input, context) => {
     return {
         ...(input.appIdClientRegex != null && { appIdClientRegex: input.appIdClientRegex }),
         ...(input.awsRegion != null && { awsRegion: input.awsRegion }),
@@ -3717,32 +3687,28 @@ const serializeAws_restJson1UserPoolConfig = (input, context) => {
         ...(input.userPoolId != null && { userPoolId: input.userPoolId }),
     };
 };
-const deserializeAws_restJson1AdditionalAuthenticationProvider = (output, context) => {
+const de_AdditionalAuthenticationProvider = (output, context) => {
     return {
         authenticationType: __expectString(output.authenticationType),
         lambdaAuthorizerConfig: output.lambdaAuthorizerConfig != null
-            ? deserializeAws_restJson1LambdaAuthorizerConfig(output.lambdaAuthorizerConfig, context)
-            : undefined,
-        openIDConnectConfig: output.openIDConnectConfig != null
-            ? deserializeAws_restJson1OpenIDConnectConfig(output.openIDConnectConfig, context)
-            : undefined,
-        userPoolConfig: output.userPoolConfig != null
-            ? deserializeAws_restJson1CognitoUserPoolConfig(output.userPoolConfig, context)
+            ? de_LambdaAuthorizerConfig(output.lambdaAuthorizerConfig, context)
             : undefined,
+        openIDConnectConfig: output.openIDConnectConfig != null ? de_OpenIDConnectConfig(output.openIDConnectConfig, context) : undefined,
+        userPoolConfig: output.userPoolConfig != null ? de_CognitoUserPoolConfig(output.userPoolConfig, context) : undefined,
     };
 };
-const deserializeAws_restJson1AdditionalAuthenticationProviders = (output, context) => {
+const de_AdditionalAuthenticationProviders = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AdditionalAuthenticationProvider(entry, context);
+        return de_AdditionalAuthenticationProvider(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ApiAssociation = (output, context) => {
+const de_ApiAssociation = (output, context) => {
     return {
         apiId: __expectString(output.apiId),
         associationStatus: __expectString(output.associationStatus),
@@ -3750,7 +3716,7 @@ const deserializeAws_restJson1ApiAssociation = (output, context) => {
         domainName: __expectString(output.domainName),
     };
 };
-const deserializeAws_restJson1ApiCache = (output, context) => {
+const de_ApiCache = (output, context) => {
     return {
         apiCachingBehavior: __expectString(output.apiCachingBehavior),
         atRestEncryptionEnabled: __expectBoolean(output.atRestEncryptionEnabled),
@@ -3760,7 +3726,7 @@ const deserializeAws_restJson1ApiCache = (output, context) => {
         type: __expectString(output.type),
     };
 };
-const deserializeAws_restJson1ApiKey = (output, context) => {
+const de_ApiKey = (output, context) => {
     return {
         deletes: __expectLong(output.deletes),
         description: __expectString(output.description),
@@ -3768,47 +3734,47 @@ const deserializeAws_restJson1ApiKey = (output, context) => {
         id: __expectString(output.id),
     };
 };
-const deserializeAws_restJson1ApiKeys = (output, context) => {
+const de_ApiKeys = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ApiKey(entry, context);
+        return de_ApiKey(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AppSyncRuntime = (output, context) => {
+const de_AppSyncRuntime = (output, context) => {
     return {
         name: __expectString(output.name),
         runtimeVersion: __expectString(output.runtimeVersion),
     };
 };
-const deserializeAws_restJson1AuthorizationConfig = (output, context) => {
+const de_AuthorizationConfig = (output, context) => {
     return {
         authorizationType: __expectString(output.authorizationType),
-        awsIamConfig: output.awsIamConfig != null ? deserializeAws_restJson1AwsIamConfig(output.awsIamConfig, context) : undefined,
+        awsIamConfig: output.awsIamConfig != null ? de_AwsIamConfig(output.awsIamConfig, context) : undefined,
     };
 };
-const deserializeAws_restJson1AwsIamConfig = (output, context) => {
+const de_AwsIamConfig = (output, context) => {
     return {
         signingRegion: __expectString(output.signingRegion),
         signingServiceName: __expectString(output.signingServiceName),
     };
 };
-const deserializeAws_restJson1BadRequestDetail = (output, context) => {
+const de_BadRequestDetail = (output, context) => {
     return {
-        codeErrors: output.codeErrors != null ? deserializeAws_restJson1CodeErrors(output.codeErrors, context) : undefined,
+        codeErrors: output.codeErrors != null ? de_CodeErrors(output.codeErrors, context) : undefined,
     };
 };
-const deserializeAws_restJson1CachingConfig = (output, context) => {
+const de_CachingConfig = (output, context) => {
     return {
-        cachingKeys: output.cachingKeys != null ? deserializeAws_restJson1CachingKeys(output.cachingKeys, context) : undefined,
+        cachingKeys: output.cachingKeys != null ? de_CachingKeys(output.cachingKeys, context) : undefined,
         ttl: __expectLong(output.ttl),
     };
 };
-const deserializeAws_restJson1CachingKeys = (output, context) => {
+const de_CachingKeys = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -3819,85 +3785,79 @@ const deserializeAws_restJson1CachingKeys = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1CodeError = (output, context) => {
+const de_CodeError = (output, context) => {
     return {
         errorType: __expectString(output.errorType),
-        location: output.location != null ? deserializeAws_restJson1CodeErrorLocation(output.location, context) : undefined,
+        location: output.location != null ? de_CodeErrorLocation(output.location, context) : undefined,
         value: __expectString(output.value),
     };
 };
-const deserializeAws_restJson1CodeErrorLocation = (output, context) => {
+const de_CodeErrorLocation = (output, context) => {
     return {
         column: __expectInt32(output.column),
         line: __expectInt32(output.line),
         span: __expectInt32(output.span),
     };
 };
-const deserializeAws_restJson1CodeErrors = (output, context) => {
+const de_CodeErrors = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1CodeError(entry, context);
+        return de_CodeError(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1CognitoUserPoolConfig = (output, context) => {
+const de_CognitoUserPoolConfig = (output, context) => {
     return {
         appIdClientRegex: __expectString(output.appIdClientRegex),
         awsRegion: __expectString(output.awsRegion),
         userPoolId: __expectString(output.userPoolId),
     };
 };
-const deserializeAws_restJson1DataSource = (output, context) => {
+const de_DataSource = (output, context) => {
     return {
         dataSourceArn: __expectString(output.dataSourceArn),
         description: __expectString(output.description),
-        dynamodbConfig: output.dynamodbConfig != null
-            ? deserializeAws_restJson1DynamodbDataSourceConfig(output.dynamodbConfig, context)
-            : undefined,
+        dynamodbConfig: output.dynamodbConfig != null ? de_DynamodbDataSourceConfig(output.dynamodbConfig, context) : undefined,
         elasticsearchConfig: output.elasticsearchConfig != null
-            ? deserializeAws_restJson1ElasticsearchDataSourceConfig(output.elasticsearchConfig, context)
-            : undefined,
-        eventBridgeConfig: output.eventBridgeConfig != null
-            ? deserializeAws_restJson1EventBridgeDataSourceConfig(output.eventBridgeConfig, context)
-            : undefined,
-        httpConfig: output.httpConfig != null ? deserializeAws_restJson1HttpDataSourceConfig(output.httpConfig, context) : undefined,
-        lambdaConfig: output.lambdaConfig != null
-            ? deserializeAws_restJson1LambdaDataSourceConfig(output.lambdaConfig, context)
+            ? de_ElasticsearchDataSourceConfig(output.elasticsearchConfig, context)
             : undefined,
+        eventBridgeConfig: output.eventBridgeConfig != null ? de_EventBridgeDataSourceConfig(output.eventBridgeConfig, context) : undefined,
+        httpConfig: output.httpConfig != null ? de_HttpDataSourceConfig(output.httpConfig, context) : undefined,
+        lambdaConfig: output.lambdaConfig != null ? de_LambdaDataSourceConfig(output.lambdaConfig, context) : undefined,
         name: __expectString(output.name),
         openSearchServiceConfig: output.openSearchServiceConfig != null
-            ? deserializeAws_restJson1OpenSearchServiceDataSourceConfig(output.openSearchServiceConfig, context)
+            ? de_OpenSearchServiceDataSourceConfig(output.openSearchServiceConfig, context)
             : undefined,
         relationalDatabaseConfig: output.relationalDatabaseConfig != null
-            ? deserializeAws_restJson1RelationalDatabaseDataSourceConfig(output.relationalDatabaseConfig, context)
+            ? de_RelationalDatabaseDataSourceConfig(output.relationalDatabaseConfig, context)
             : undefined,
         serviceRoleArn: __expectString(output.serviceRoleArn),
         type: __expectString(output.type),
     };
 };
-const deserializeAws_restJson1DataSources = (output, context) => {
+const de_DataSources = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1DataSource(entry, context);
+        return de_DataSource(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1DeltaSyncConfig = (output, context) => {
+const de_DeltaSyncConfig = (output, context) => {
     return {
         baseTableTTL: __expectLong(output.baseTableTTL),
         deltaSyncTableName: __expectString(output.deltaSyncTableName),
         deltaSyncTableTTL: __expectLong(output.deltaSyncTableTTL),
     };
 };
-const deserializeAws_restJson1DomainNameConfig = (output, context) => {
+const de_DomainNameConfig = (output, context) => {
     return {
         appsyncDomainName: __expectString(output.appsyncDomainName),
         certificateArn: __expectString(output.certificateArn),
@@ -3906,51 +3866,49 @@ const deserializeAws_restJson1DomainNameConfig = (output, context) => {
         hostedZoneId: __expectString(output.hostedZoneId),
     };
 };
-const deserializeAws_restJson1DomainNameConfigs = (output, context) => {
+const de_DomainNameConfigs = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1DomainNameConfig(entry, context);
+        return de_DomainNameConfig(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1DynamodbDataSourceConfig = (output, context) => {
+const de_DynamodbDataSourceConfig = (output, context) => {
     return {
         awsRegion: __expectString(output.awsRegion),
-        deltaSyncConfig: output.deltaSyncConfig != null
-            ? deserializeAws_restJson1DeltaSyncConfig(output.deltaSyncConfig, context)
-            : undefined,
+        deltaSyncConfig: output.deltaSyncConfig != null ? de_DeltaSyncConfig(output.deltaSyncConfig, context) : undefined,
         tableName: __expectString(output.tableName),
         useCallerCredentials: __expectBoolean(output.useCallerCredentials),
         versioned: __expectBoolean(output.versioned),
     };
 };
-const deserializeAws_restJson1ElasticsearchDataSourceConfig = (output, context) => {
+const de_ElasticsearchDataSourceConfig = (output, context) => {
     return {
         awsRegion: __expectString(output.awsRegion),
         endpoint: __expectString(output.endpoint),
     };
 };
-const deserializeAws_restJson1ErrorDetail = (output, context) => {
+const de_ErrorDetail = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_restJson1EvaluateCodeErrorDetail = (output, context) => {
+const de_EvaluateCodeErrorDetail = (output, context) => {
     return {
-        codeErrors: output.codeErrors != null ? deserializeAws_restJson1CodeErrors(output.codeErrors, context) : undefined,
+        codeErrors: output.codeErrors != null ? de_CodeErrors(output.codeErrors, context) : undefined,
         message: __expectString(output.message),
     };
 };
-const deserializeAws_restJson1EventBridgeDataSourceConfig = (output, context) => {
+const de_EventBridgeDataSourceConfig = (output, context) => {
     return {
         eventBusArn: __expectString(output.eventBusArn),
     };
 };
-const deserializeAws_restJson1FunctionConfiguration = (output, context) => {
+const de_FunctionConfiguration = (output, context) => {
     return {
         code: __expectString(output.code),
         dataSourceName: __expectString(output.dataSourceName),
@@ -3962,22 +3920,22 @@ const deserializeAws_restJson1FunctionConfiguration = (output, context) => {
         name: __expectString(output.name),
         requestMappingTemplate: __expectString(output.requestMappingTemplate),
         responseMappingTemplate: __expectString(output.responseMappingTemplate),
-        runtime: output.runtime != null ? deserializeAws_restJson1AppSyncRuntime(output.runtime, context) : undefined,
-        syncConfig: output.syncConfig != null ? deserializeAws_restJson1SyncConfig(output.syncConfig, context) : undefined,
+        runtime: output.runtime != null ? de_AppSyncRuntime(output.runtime, context) : undefined,
+        syncConfig: output.syncConfig != null ? de_SyncConfig(output.syncConfig, context) : undefined,
     };
 };
-const deserializeAws_restJson1Functions = (output, context) => {
+const de_Functions = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1FunctionConfiguration(entry, context);
+        return de_FunctionConfiguration(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1FunctionsIds = (output, context) => {
+const de_FunctionsIds = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -3988,75 +3946,69 @@ const deserializeAws_restJson1FunctionsIds = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1GraphqlApi = (output, context) => {
+const de_GraphqlApi = (output, context) => {
     return {
         additionalAuthenticationProviders: output.additionalAuthenticationProviders != null
-            ? deserializeAws_restJson1AdditionalAuthenticationProviders(output.additionalAuthenticationProviders, context)
+            ? de_AdditionalAuthenticationProviders(output.additionalAuthenticationProviders, context)
             : undefined,
         apiId: __expectString(output.apiId),
         arn: __expectString(output.arn),
         authenticationType: __expectString(output.authenticationType),
         lambdaAuthorizerConfig: output.lambdaAuthorizerConfig != null
-            ? deserializeAws_restJson1LambdaAuthorizerConfig(output.lambdaAuthorizerConfig, context)
+            ? de_LambdaAuthorizerConfig(output.lambdaAuthorizerConfig, context)
             : undefined,
-        logConfig: output.logConfig != null ? deserializeAws_restJson1LogConfig(output.logConfig, context) : undefined,
+        logConfig: output.logConfig != null ? de_LogConfig(output.logConfig, context) : undefined,
         name: __expectString(output.name),
-        openIDConnectConfig: output.openIDConnectConfig != null
-            ? deserializeAws_restJson1OpenIDConnectConfig(output.openIDConnectConfig, context)
-            : undefined,
-        tags: output.tags != null ? deserializeAws_restJson1TagMap(output.tags, context) : undefined,
-        uris: output.uris != null ? deserializeAws_restJson1MapOfStringToString(output.uris, context) : undefined,
-        userPoolConfig: output.userPoolConfig != null
-            ? deserializeAws_restJson1UserPoolConfig(output.userPoolConfig, context)
-            : undefined,
+        openIDConnectConfig: output.openIDConnectConfig != null ? de_OpenIDConnectConfig(output.openIDConnectConfig, context) : undefined,
+        tags: output.tags != null ? de_TagMap(output.tags, context) : undefined,
+        uris: output.uris != null ? de_MapOfStringToString(output.uris, context) : undefined,
+        userPoolConfig: output.userPoolConfig != null ? de_UserPoolConfig(output.userPoolConfig, context) : undefined,
         wafWebAclArn: __expectString(output.wafWebAclArn),
         xrayEnabled: __expectBoolean(output.xrayEnabled),
     };
 };
-const deserializeAws_restJson1GraphqlApis = (output, context) => {
+const de_GraphqlApis = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1GraphqlApi(entry, context);
+        return de_GraphqlApi(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1HttpDataSourceConfig = (output, context) => {
+const de_HttpDataSourceConfig = (output, context) => {
     return {
-        authorizationConfig: output.authorizationConfig != null
-            ? deserializeAws_restJson1AuthorizationConfig(output.authorizationConfig, context)
-            : undefined,
+        authorizationConfig: output.authorizationConfig != null ? de_AuthorizationConfig(output.authorizationConfig, context) : undefined,
         endpoint: __expectString(output.endpoint),
     };
 };
-const deserializeAws_restJson1LambdaAuthorizerConfig = (output, context) => {
+const de_LambdaAuthorizerConfig = (output, context) => {
     return {
         authorizerResultTtlInSeconds: __expectInt32(output.authorizerResultTtlInSeconds),
         authorizerUri: __expectString(output.authorizerUri),
         identityValidationExpression: __expectString(output.identityValidationExpression),
     };
 };
-const deserializeAws_restJson1LambdaConflictHandlerConfig = (output, context) => {
+const de_LambdaConflictHandlerConfig = (output, context) => {
     return {
         lambdaConflictHandlerArn: __expectString(output.lambdaConflictHandlerArn),
     };
 };
-const deserializeAws_restJson1LambdaDataSourceConfig = (output, context) => {
+const de_LambdaDataSourceConfig = (output, context) => {
     return {
         lambdaFunctionArn: __expectString(output.lambdaFunctionArn),
     };
 };
-const deserializeAws_restJson1LogConfig = (output, context) => {
+const de_LogConfig = (output, context) => {
     return {
         cloudWatchLogsRoleArn: __expectString(output.cloudWatchLogsRoleArn),
         excludeVerboseContent: __expectBoolean(output.excludeVerboseContent),
         fieldLogLevel: __expectString(output.fieldLogLevel),
     };
 };
-const deserializeAws_restJson1Logs = (output, context) => {
+const de_Logs = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -4067,7 +4019,7 @@ const deserializeAws_restJson1Logs = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1MapOfStringToString = (output, context) => {
+const de_MapOfStringToString = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -4076,7 +4028,7 @@ const deserializeAws_restJson1MapOfStringToString = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_restJson1OpenIDConnectConfig = (output, context) => {
+const de_OpenIDConnectConfig = (output, context) => {
     return {
         authTTL: __expectLong(output.authTTL),
         clientId: __expectString(output.clientId),
@@ -4084,18 +4036,18 @@ const deserializeAws_restJson1OpenIDConnectConfig = (output, context) => {
         issuer: __expectString(output.issuer),
     };
 };
-const deserializeAws_restJson1OpenSearchServiceDataSourceConfig = (output, context) => {
+const de_OpenSearchServiceDataSourceConfig = (output, context) => {
     return {
         awsRegion: __expectString(output.awsRegion),
         endpoint: __expectString(output.endpoint),
     };
 };
-const deserializeAws_restJson1PipelineConfig = (output, context) => {
+const de_PipelineConfig = (output, context) => {
     return {
-        functions: output.functions != null ? deserializeAws_restJson1FunctionsIds(output.functions, context) : undefined,
+        functions: output.functions != null ? de_FunctionsIds(output.functions, context) : undefined,
     };
 };
-const deserializeAws_restJson1RdsHttpEndpointConfig = (output, context) => {
+const de_RdsHttpEndpointConfig = (output, context) => {
     return {
         awsRegion: __expectString(output.awsRegion),
         awsSecretStoreArn: __expectString(output.awsSecretStoreArn),
@@ -4104,54 +4056,52 @@ const deserializeAws_restJson1RdsHttpEndpointConfig = (output, context) => {
         schema: __expectString(output.schema),
     };
 };
-const deserializeAws_restJson1RelationalDatabaseDataSourceConfig = (output, context) => {
+const de_RelationalDatabaseDataSourceConfig = (output, context) => {
     return {
         rdsHttpEndpointConfig: output.rdsHttpEndpointConfig != null
-            ? deserializeAws_restJson1RdsHttpEndpointConfig(output.rdsHttpEndpointConfig, context)
+            ? de_RdsHttpEndpointConfig(output.rdsHttpEndpointConfig, context)
             : undefined,
         relationalDatabaseSourceType: __expectString(output.relationalDatabaseSourceType),
     };
 };
-const deserializeAws_restJson1Resolver = (output, context) => {
+const de_Resolver = (output, context) => {
     return {
-        cachingConfig: output.cachingConfig != null ? deserializeAws_restJson1CachingConfig(output.cachingConfig, context) : undefined,
+        cachingConfig: output.cachingConfig != null ? de_CachingConfig(output.cachingConfig, context) : undefined,
         code: __expectString(output.code),
         dataSourceName: __expectString(output.dataSourceName),
         fieldName: __expectString(output.fieldName),
         kind: __expectString(output.kind),
         maxBatchSize: __expectInt32(output.maxBatchSize),
-        pipelineConfig: output.pipelineConfig != null
-            ? deserializeAws_restJson1PipelineConfig(output.pipelineConfig, context)
-            : undefined,
+        pipelineConfig: output.pipelineConfig != null ? de_PipelineConfig(output.pipelineConfig, context) : undefined,
         requestMappingTemplate: __expectString(output.requestMappingTemplate),
         resolverArn: __expectString(output.resolverArn),
         responseMappingTemplate: __expectString(output.responseMappingTemplate),
-        runtime: output.runtime != null ? deserializeAws_restJson1AppSyncRuntime(output.runtime, context) : undefined,
-        syncConfig: output.syncConfig != null ? deserializeAws_restJson1SyncConfig(output.syncConfig, context) : undefined,
+        runtime: output.runtime != null ? de_AppSyncRuntime(output.runtime, context) : undefined,
+        syncConfig: output.syncConfig != null ? de_SyncConfig(output.syncConfig, context) : undefined,
         typeName: __expectString(output.typeName),
     };
 };
-const deserializeAws_restJson1Resolvers = (output, context) => {
+const de_Resolvers = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Resolver(entry, context);
+        return de_Resolver(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1SyncConfig = (output, context) => {
+const de_SyncConfig = (output, context) => {
     return {
         conflictDetection: __expectString(output.conflictDetection),
         conflictHandler: __expectString(output.conflictHandler),
         lambdaConflictHandlerConfig: output.lambdaConflictHandlerConfig != null
-            ? deserializeAws_restJson1LambdaConflictHandlerConfig(output.lambdaConflictHandlerConfig, context)
+            ? de_LambdaConflictHandlerConfig(output.lambdaConflictHandlerConfig, context)
             : undefined,
     };
 };
-const deserializeAws_restJson1TagMap = (output, context) => {
+const de_TagMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -4160,7 +4110,7 @@ const deserializeAws_restJson1TagMap = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_restJson1Type = (output, context) => {
+const de_Type = (output, context) => {
     return {
         arn: __expectString(output.arn),
         definition: __expectString(output.definition),
@@ -4169,18 +4119,18 @@ const deserializeAws_restJson1Type = (output, context) => {
         name: __expectString(output.name),
     };
 };
-const deserializeAws_restJson1TypeList = (output, context) => {
+const de_TypeList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Type(entry, context);
+        return de_Type(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1UserPoolConfig = (output, context) => {
+const de_UserPoolConfig = (output, context) => {
     return {
         appIdClientRegex: __expectString(output.appIdClientRegex),
         awsRegion: __expectString(output.awsRegion),