@aws-sdk/client-securitylake 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, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, expectUnion as __expectUnion, map as __map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, strictParseInt32 as __strictParseInt32, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { AccessDeniedException, AccountNotFoundException, BucketNotFoundException, ConcurrentModificationException, ConflictException, ConflictSourceNamesException, ConflictSubscriptionException, EventBridgeException, InternalServerException, InvalidInputException, ResourceNotFoundException, S3Exception, ServiceQuotaExceededException, SourceType, ThrottlingException, ValidationException, } from "../models/models_0";
 import { SecurityLakeServiceException as __BaseException } from "../models/SecurityLakeServiceException";
-export const serializeAws_restJson1CreateAwsLogSourceCommand = async (input, context) => {
+export const se_CreateAwsLogSourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -11,15 +11,15 @@ export const serializeAws_restJson1CreateAwsLogSourceCommand = async (input, con
     let body;
     body = JSON.stringify({
         ...(input.enableAllDimensions != null && {
-            enableAllDimensions: serializeAws_restJson1AllDimensionsMap(input.enableAllDimensions, context),
+            enableAllDimensions: se_AllDimensionsMap(input.enableAllDimensions, context),
         }),
         ...(input.enableSingleDimension != null && {
-            enableSingleDimension: serializeAws_restJson1InputSet(input.enableSingleDimension, context),
+            enableSingleDimension: se_InputSet(input.enableSingleDimension, context),
         }),
         ...(input.enableTwoDimensions != null && {
-            enableTwoDimensions: serializeAws_restJson1TwoDimensionsMap(input.enableTwoDimensions, context),
+            enableTwoDimensions: se_TwoDimensionsMap(input.enableTwoDimensions, context),
         }),
-        ...(input.inputOrder != null && { inputOrder: serializeAws_restJson1DimensionSet(input.inputOrder, context) }),
+        ...(input.inputOrder != null && { inputOrder: se_DimensionSet(input.inputOrder, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -31,7 +31,7 @@ export const serializeAws_restJson1CreateAwsLogSourceCommand = async (input, con
         body,
     });
 };
-export const serializeAws_restJson1CreateCustomLogSourceCommand = async (input, context) => {
+export const se_CreateCustomLogSourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -54,7 +54,7 @@ export const serializeAws_restJson1CreateCustomLogSourceCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1CreateDatalakeCommand = async (input, context) => {
+export const se_CreateDatalakeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -63,11 +63,11 @@ export const serializeAws_restJson1CreateDatalakeCommand = async (input, context
     let body;
     body = JSON.stringify({
         ...(input.configurations != null && {
-            configurations: serializeAws_restJson1LakeConfigurationRequestMap(input.configurations, context),
+            configurations: se_LakeConfigurationRequestMap(input.configurations, context),
         }),
         ...(input.enableAll != null && { enableAll: input.enableAll }),
         ...(input.metaStoreManagerRoleArn != null && { metaStoreManagerRoleArn: input.metaStoreManagerRoleArn }),
-        ...(input.regions != null && { regions: serializeAws_restJson1RegionSet(input.regions, context) }),
+        ...(input.regions != null && { regions: se_RegionSet(input.regions, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -79,7 +79,7 @@ export const serializeAws_restJson1CreateDatalakeCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1CreateDatalakeAutoEnableCommand = async (input, context) => {
+export const se_CreateDatalakeAutoEnableCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -88,7 +88,7 @@ export const serializeAws_restJson1CreateDatalakeAutoEnableCommand = async (inpu
     let body;
     body = JSON.stringify({
         ...(input.configurationForNewAccounts != null && {
-            configurationForNewAccounts: serializeAws_restJson1AutoEnableNewRegionConfigurationList(input.configurationForNewAccounts, context),
+            configurationForNewAccounts: se_AutoEnableNewRegionConfigurationList(input.configurationForNewAccounts, context),
         }),
     });
     return new __HttpRequest({
@@ -101,7 +101,7 @@ export const serializeAws_restJson1CreateDatalakeAutoEnableCommand = async (inpu
         body,
     });
 };
-export const serializeAws_restJson1CreateDatalakeDelegatedAdminCommand = async (input, context) => {
+export const se_CreateDatalakeDelegatedAdminCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -121,7 +121,7 @@ export const serializeAws_restJson1CreateDatalakeDelegatedAdminCommand = async (
         body,
     });
 };
-export const serializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand = async (input, context) => {
+export const se_CreateDatalakeExceptionsSubscriptionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -142,7 +142,7 @@ export const serializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand =
         body,
     });
 };
-export const serializeAws_restJson1CreateSubscriberCommand = async (input, context) => {
+export const se_CreateSubscriberCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -150,10 +150,10 @@ export const serializeAws_restJson1CreateSubscriberCommand = async (input, conte
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/subscribers";
     let body;
     body = JSON.stringify({
-        ...(input.accessTypes != null && { accessTypes: serializeAws_restJson1AccessTypeList(input.accessTypes, context) }),
+        ...(input.accessTypes != null && { accessTypes: se_AccessTypeList(input.accessTypes, context) }),
         ...(input.accountId != null && { accountId: input.accountId }),
         ...(input.externalId != null && { externalId: input.externalId }),
-        ...(input.sourceTypes != null && { sourceTypes: serializeAws_restJson1SourceTypeList(input.sourceTypes, context) }),
+        ...(input.sourceTypes != null && { sourceTypes: se_SourceTypeList(input.sourceTypes, context) }),
         ...(input.subscriberDescription != null && { subscriberDescription: input.subscriberDescription }),
         ...(input.subscriberName != null && { subscriberName: input.subscriberName }),
     });
@@ -167,7 +167,7 @@ export const serializeAws_restJson1CreateSubscriberCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand = async (input, context) => {
+export const se_CreateSubscriptionNotificationConfigurationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -194,7 +194,7 @@ export const serializeAws_restJson1CreateSubscriptionNotificationConfigurationCo
         body,
     });
 };
-export const serializeAws_restJson1DeleteAwsLogSourceCommand = async (input, context) => {
+export const se_DeleteAwsLogSourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -203,15 +203,15 @@ export const serializeAws_restJson1DeleteAwsLogSourceCommand = async (input, con
     let body;
     body = JSON.stringify({
         ...(input.disableAllDimensions != null && {
-            disableAllDimensions: serializeAws_restJson1AllDimensionsMap(input.disableAllDimensions, context),
+            disableAllDimensions: se_AllDimensionsMap(input.disableAllDimensions, context),
         }),
         ...(input.disableSingleDimension != null && {
-            disableSingleDimension: serializeAws_restJson1InputSet(input.disableSingleDimension, context),
+            disableSingleDimension: se_InputSet(input.disableSingleDimension, context),
         }),
         ...(input.disableTwoDimensions != null && {
-            disableTwoDimensions: serializeAws_restJson1TwoDimensionsMap(input.disableTwoDimensions, context),
+            disableTwoDimensions: se_TwoDimensionsMap(input.disableTwoDimensions, context),
         }),
-        ...(input.inputOrder != null && { inputOrder: serializeAws_restJson1DimensionSet(input.inputOrder, context) }),
+        ...(input.inputOrder != null && { inputOrder: se_DimensionSet(input.inputOrder, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -223,7 +223,7 @@ export const serializeAws_restJson1DeleteAwsLogSourceCommand = async (input, con
         body,
     });
 };
-export const serializeAws_restJson1DeleteCustomLogSourceCommand = async (input, context) => {
+export const se_DeleteCustomLogSourceCommand = 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/logsources/custom";
@@ -242,7 +242,7 @@ export const serializeAws_restJson1DeleteCustomLogSourceCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1DeleteDatalakeCommand = async (input, context) => {
+export const se_DeleteDatalakeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -260,7 +260,7 @@ export const serializeAws_restJson1DeleteDatalakeCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1DeleteDatalakeAutoEnableCommand = async (input, context) => {
+export const se_DeleteDatalakeAutoEnableCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -269,7 +269,7 @@ export const serializeAws_restJson1DeleteDatalakeAutoEnableCommand = async (inpu
     let body;
     body = JSON.stringify({
         ...(input.removeFromConfigurationForNewAccounts != null && {
-            removeFromConfigurationForNewAccounts: serializeAws_restJson1AutoEnableNewRegionConfigurationList(input.removeFromConfigurationForNewAccounts, context),
+            removeFromConfigurationForNewAccounts: se_AutoEnableNewRegionConfigurationList(input.removeFromConfigurationForNewAccounts, context),
         }),
     });
     return new __HttpRequest({
@@ -282,7 +282,7 @@ export const serializeAws_restJson1DeleteDatalakeAutoEnableCommand = async (inpu
         body,
     });
 };
-export const serializeAws_restJson1DeleteDatalakeDelegatedAdminCommand = async (input, context) => {
+export const se_DeleteDatalakeDelegatedAdminCommand = 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/datalake/delegate/{account}";
@@ -298,7 +298,7 @@ export const serializeAws_restJson1DeleteDatalakeDelegatedAdminCommand = async (
         body,
     });
 };
-export const serializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand = async (input, context) => {
+export const se_DeleteDatalakeExceptionsSubscriptionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -316,7 +316,7 @@ export const serializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand =
         body,
     });
 };
-export const serializeAws_restJson1DeleteSubscriberCommand = async (input, context) => {
+export const se_DeleteSubscriberCommand = 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/subscribers";
@@ -335,7 +335,7 @@ export const serializeAws_restJson1DeleteSubscriberCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand = async (input, context) => {
+export const se_DeleteSubscriptionNotificationConfigurationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -352,7 +352,7 @@ export const serializeAws_restJson1DeleteSubscriptionNotificationConfigurationCo
         body,
     });
 };
-export const serializeAws_restJson1GetDatalakeCommand = async (input, context) => {
+export const se_GetDatalakeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -370,7 +370,7 @@ export const serializeAws_restJson1GetDatalakeCommand = async (input, context) =
         body,
     });
 };
-export const serializeAws_restJson1GetDatalakeAutoEnableCommand = async (input, context) => {
+export const se_GetDatalakeAutoEnableCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -388,7 +388,7 @@ export const serializeAws_restJson1GetDatalakeAutoEnableCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1GetDatalakeExceptionsExpiryCommand = async (input, context) => {
+export const se_GetDatalakeExceptionsExpiryCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -406,7 +406,7 @@ export const serializeAws_restJson1GetDatalakeExceptionsExpiryCommand = async (i
         body,
     });
 };
-export const serializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand = async (input, context) => {
+export const se_GetDatalakeExceptionsSubscriptionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -424,7 +424,7 @@ export const serializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand = as
         body,
     });
 };
-export const serializeAws_restJson1GetDatalakeStatusCommand = async (input, context) => {
+export const se_GetDatalakeStatusCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -432,7 +432,7 @@ export const serializeAws_restJson1GetDatalakeStatusCommand = async (input, cont
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/status";
     let body;
     body = JSON.stringify({
-        ...(input.accountSet != null && { accountSet: serializeAws_restJson1InputSet(input.accountSet, context) }),
+        ...(input.accountSet != null && { accountSet: se_InputSet(input.accountSet, context) }),
         ...(input.maxAccountResults != null && { maxAccountResults: input.maxAccountResults }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
     });
@@ -446,7 +446,7 @@ export const serializeAws_restJson1GetDatalakeStatusCommand = async (input, cont
         body,
     });
 };
-export const serializeAws_restJson1GetSubscriberCommand = async (input, context) => {
+export const se_GetSubscriberCommand = 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/subscribers/{id}";
@@ -462,7 +462,7 @@ export const serializeAws_restJson1GetSubscriberCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1ListDatalakeExceptionsCommand = async (input, context) => {
+export const se_ListDatalakeExceptionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -472,7 +472,7 @@ export const serializeAws_restJson1ListDatalakeExceptionsCommand = async (input,
     body = JSON.stringify({
         ...(input.maxFailures != null && { maxFailures: input.maxFailures }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
-        ...(input.regionSet != null && { regionSet: serializeAws_restJson1RegionSet(input.regionSet, context) }),
+        ...(input.regionSet != null && { regionSet: se_RegionSet(input.regionSet, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -484,7 +484,7 @@ export const serializeAws_restJson1ListDatalakeExceptionsCommand = async (input,
         body,
     });
 };
-export const serializeAws_restJson1ListLogSourcesCommand = async (input, context) => {
+export const se_ListLogSourcesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -492,15 +492,13 @@ export const serializeAws_restJson1ListLogSourcesCommand = async (input, context
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/logsources/list";
     let body;
     body = JSON.stringify({
-        ...(input.inputOrder != null && { inputOrder: serializeAws_restJson1DimensionSet(input.inputOrder, context) }),
+        ...(input.inputOrder != null && { inputOrder: se_DimensionSet(input.inputOrder, context) }),
         ...(input.listAllDimensions != null && {
-            listAllDimensions: serializeAws_restJson1AllDimensionsMap(input.listAllDimensions, context),
-        }),
-        ...(input.listSingleDimension != null && {
-            listSingleDimension: serializeAws_restJson1InputSet(input.listSingleDimension, context),
+            listAllDimensions: se_AllDimensionsMap(input.listAllDimensions, context),
         }),
+        ...(input.listSingleDimension != null && { listSingleDimension: se_InputSet(input.listSingleDimension, context) }),
         ...(input.listTwoDimensions != null && {
-            listTwoDimensions: serializeAws_restJson1TwoDimensionsMap(input.listTwoDimensions, context),
+            listTwoDimensions: se_TwoDimensionsMap(input.listTwoDimensions, context),
         }),
         ...(input.maxResults != null && { maxResults: input.maxResults }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
@@ -515,7 +513,7 @@ export const serializeAws_restJson1ListLogSourcesCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1ListSubscribersCommand = async (input, context) => {
+export const se_ListSubscribersCommand = 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/subscribers";
@@ -535,7 +533,7 @@ export const serializeAws_restJson1ListSubscribersCommand = async (input, contex
         body,
     });
 };
-export const serializeAws_restJson1UpdateDatalakeCommand = async (input, context) => {
+export const se_UpdateDatalakeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -544,7 +542,7 @@ export const serializeAws_restJson1UpdateDatalakeCommand = async (input, context
     let body;
     body = JSON.stringify({
         ...(input.configurations != null && {
-            configurations: serializeAws_restJson1LakeConfigurationRequestMap(input.configurations, context),
+            configurations: se_LakeConfigurationRequestMap(input.configurations, context),
         }),
     });
     return new __HttpRequest({
@@ -557,7 +555,7 @@ export const serializeAws_restJson1UpdateDatalakeCommand = async (input, context
         body,
     });
 };
-export const serializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand = async (input, context) => {
+export const se_UpdateDatalakeExceptionsExpiryCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -577,7 +575,7 @@ export const serializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand = async
         body,
     });
 };
-export const serializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand = async (input, context) => {
+export const se_UpdateDatalakeExceptionsSubscriptionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -598,7 +596,7 @@ export const serializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand =
         body,
     });
 };
-export const serializeAws_restJson1UpdateSubscriberCommand = async (input, context) => {
+export const se_UpdateSubscriberCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -608,7 +606,7 @@ export const serializeAws_restJson1UpdateSubscriberCommand = async (input, conte
     let body;
     body = JSON.stringify({
         ...(input.externalId != null && { externalId: input.externalId }),
-        ...(input.sourceTypes != null && { sourceTypes: serializeAws_restJson1SourceTypeList(input.sourceTypes, context) }),
+        ...(input.sourceTypes != null && { sourceTypes: se_SourceTypeList(input.sourceTypes, context) }),
         ...(input.subscriberDescription != null && { subscriberDescription: input.subscriberDescription }),
         ...(input.subscriberName != null && { subscriberName: input.subscriberName }),
     });
@@ -622,7 +620,7 @@ export const serializeAws_restJson1UpdateSubscriberCommand = async (input, conte
         body,
     });
 };
-export const serializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand = async (input, context) => {
+export const se_UpdateSubscriptionNotificationConfigurationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -649,23 +647,23 @@ export const serializeAws_restJson1UpdateSubscriptionNotificationConfigurationCo
         body,
     });
 };
-export const deserializeAws_restJson1CreateAwsLogSourceCommand = async (output, context) => {
+export const de_CreateAwsLogSourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateAwsLogSourceCommandError(output, context);
+        return de_CreateAwsLogSourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.failed != null) {
-        contents.failed = deserializeAws_restJson1AccountList(data.failed, context);
+        contents.failed = de_AccountList(data.failed, context);
     }
     if (data.processing != null) {
-        contents.processing = deserializeAws_restJson1AccountList(data.processing, context);
+        contents.processing = de_AccountList(data.processing, context);
     }
     return contents;
 };
-const deserializeAws_restJson1CreateAwsLogSourceCommandError = async (output, context) => {
+const de_CreateAwsLogSourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -674,22 +672,22 @@ const deserializeAws_restJson1CreateAwsLogSourceCommandError = async (output, co
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "S3Exception":
         case "com.amazonaws.securitylake#S3Exception":
-            throw await deserializeAws_restJson1S3ExceptionResponse(parsedOutput, context);
+            throw await de_S3ExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -700,9 +698,9 @@ const deserializeAws_restJson1CreateAwsLogSourceCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_restJson1CreateCustomLogSourceCommand = async (output, context) => {
+export const de_CreateCustomLogSourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateCustomLogSourceCommandError(output, context);
+        return de_CreateCustomLogSourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -725,7 +723,7 @@ export const deserializeAws_restJson1CreateCustomLogSourceCommand = async (outpu
     }
     return contents;
 };
-const deserializeAws_restJson1CreateCustomLogSourceCommandError = async (output, context) => {
+const de_CreateCustomLogSourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -734,25 +732,25 @@ const deserializeAws_restJson1CreateCustomLogSourceCommandError = async (output,
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "BucketNotFoundException":
         case "com.amazonaws.securitylake#BucketNotFoundException":
-            throw await deserializeAws_restJson1BucketNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_BucketNotFoundExceptionRes(parsedOutput, context);
         case "ConflictSourceNamesException":
         case "com.amazonaws.securitylake#ConflictSourceNamesException":
-            throw await deserializeAws_restJson1ConflictSourceNamesExceptionResponse(parsedOutput, context);
+            throw await de_ConflictSourceNamesExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -763,9 +761,9 @@ const deserializeAws_restJson1CreateCustomLogSourceCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1CreateDatalakeCommand = async (output, context) => {
+export const de_CreateDatalakeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateDatalakeCommandError(output, context);
+        return de_CreateDatalakeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -773,7 +771,7 @@ export const deserializeAws_restJson1CreateDatalakeCommand = async (output, cont
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1CreateDatalakeCommandError = async (output, context) => {
+const de_CreateDatalakeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -782,25 +780,25 @@ const deserializeAws_restJson1CreateDatalakeCommandError = async (output, contex
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.securitylake#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceQuotaExceededException":
         case "com.amazonaws.securitylake#ServiceQuotaExceededException":
-            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.securitylake#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -811,9 +809,9 @@ const deserializeAws_restJson1CreateDatalakeCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1CreateDatalakeAutoEnableCommand = async (output, context) => {
+export const de_CreateDatalakeAutoEnableCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateDatalakeAutoEnableCommandError(output, context);
+        return de_CreateDatalakeAutoEnableCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -821,7 +819,7 @@ export const deserializeAws_restJson1CreateDatalakeAutoEnableCommand = async (ou
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1CreateDatalakeAutoEnableCommandError = async (output, context) => {
+const de_CreateDatalakeAutoEnableCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -830,16 +828,16 @@ const deserializeAws_restJson1CreateDatalakeAutoEnableCommandError = async (outp
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -850,9 +848,9 @@ const deserializeAws_restJson1CreateDatalakeAutoEnableCommandError = async (outp
             });
     }
 };
-export const deserializeAws_restJson1CreateDatalakeDelegatedAdminCommand = async (output, context) => {
+export const de_CreateDatalakeDelegatedAdminCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateDatalakeDelegatedAdminCommandError(output, context);
+        return de_CreateDatalakeDelegatedAdminCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -860,7 +858,7 @@ export const deserializeAws_restJson1CreateDatalakeDelegatedAdminCommand = async
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1CreateDatalakeDelegatedAdminCommandError = async (output, context) => {
+const de_CreateDatalakeDelegatedAdminCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -869,16 +867,16 @@ const deserializeAws_restJson1CreateDatalakeDelegatedAdminCommandError = async (
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.securitylake#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -889,9 +887,9 @@ const deserializeAws_restJson1CreateDatalakeDelegatedAdminCommandError = async (
             });
     }
 };
-export const deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand = async (output, context) => {
+export const de_CreateDatalakeExceptionsSubscriptionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommandError(output, context);
+        return de_CreateDatalakeExceptionsSubscriptionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -899,7 +897,7 @@ export const deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
+const de_CreateDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -908,16 +906,16 @@ const deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommandError =
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -928,9 +926,9 @@ const deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommandError =
             });
     }
 };
-export const deserializeAws_restJson1CreateSubscriberCommand = async (output, context) => {
+export const de_CreateSubscriberCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateSubscriberCommandError(output, context);
+        return de_CreateSubscriberCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -956,7 +954,7 @@ export const deserializeAws_restJson1CreateSubscriberCommand = async (output, co
     }
     return contents;
 };
-const deserializeAws_restJson1CreateSubscriberCommandError = async (output, context) => {
+const de_CreateSubscriberCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -965,28 +963,28 @@ const deserializeAws_restJson1CreateSubscriberCommandError = async (output, cont
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "BucketNotFoundException":
         case "com.amazonaws.securitylake#BucketNotFoundException":
-            throw await deserializeAws_restJson1BucketNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_BucketNotFoundExceptionRes(parsedOutput, context);
         case "ConflictSubscriptionException":
         case "com.amazonaws.securitylake#ConflictSubscriptionException":
-            throw await deserializeAws_restJson1ConflictSubscriptionExceptionResponse(parsedOutput, context);
+            throw await de_ConflictSubscriptionExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "InvalidInputException":
         case "com.amazonaws.securitylake#InvalidInputException":
-            throw await deserializeAws_restJson1InvalidInputExceptionResponse(parsedOutput, context);
+            throw await de_InvalidInputExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -997,9 +995,9 @@ const deserializeAws_restJson1CreateSubscriberCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand = async (output, context) => {
+export const de_CreateSubscriptionNotificationConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommandError(output, context);
+        return de_CreateSubscriptionNotificationConfigurationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1010,7 +1008,7 @@ export const deserializeAws_restJson1CreateSubscriptionNotificationConfiguration
     }
     return contents;
 };
-const deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommandError = async (output, context) => {
+const de_CreateSubscriptionNotificationConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1019,25 +1017,25 @@ const deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.securitylake#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "InvalidInputException":
         case "com.amazonaws.securitylake#InvalidInputException":
-            throw await deserializeAws_restJson1InvalidInputExceptionResponse(parsedOutput, context);
+            throw await de_InvalidInputExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1048,23 +1046,23 @@ const deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand
             });
     }
 };
-export const deserializeAws_restJson1DeleteAwsLogSourceCommand = async (output, context) => {
+export const de_DeleteAwsLogSourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteAwsLogSourceCommandError(output, context);
+        return de_DeleteAwsLogSourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.failed != null) {
-        contents.failed = deserializeAws_restJson1AccountList(data.failed, context);
+        contents.failed = de_AccountList(data.failed, context);
     }
     if (data.processing != null) {
-        contents.processing = deserializeAws_restJson1AccountList(data.processing, context);
+        contents.processing = de_AccountList(data.processing, context);
     }
     return contents;
 };
-const deserializeAws_restJson1DeleteAwsLogSourceCommandError = async (output, context) => {
+const de_DeleteAwsLogSourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1073,16 +1071,16 @@ const deserializeAws_restJson1DeleteAwsLogSourceCommandError = async (output, co
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1093,9 +1091,9 @@ const deserializeAws_restJson1DeleteAwsLogSourceCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_restJson1DeleteCustomLogSourceCommand = async (output, context) => {
+export const de_DeleteCustomLogSourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteCustomLogSourceCommandError(output, context);
+        return de_DeleteCustomLogSourceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1106,7 +1104,7 @@ export const deserializeAws_restJson1DeleteCustomLogSourceCommand = async (outpu
     }
     return contents;
 };
-const deserializeAws_restJson1DeleteCustomLogSourceCommandError = async (output, context) => {
+const de_DeleteCustomLogSourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1115,25 +1113,25 @@ const deserializeAws_restJson1DeleteCustomLogSourceCommandError = async (output,
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "BucketNotFoundException":
         case "com.amazonaws.securitylake#BucketNotFoundException":
-            throw await deserializeAws_restJson1BucketNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_BucketNotFoundExceptionRes(parsedOutput, context);
         case "ConflictSourceNamesException":
         case "com.amazonaws.securitylake#ConflictSourceNamesException":
-            throw await deserializeAws_restJson1ConflictSourceNamesExceptionResponse(parsedOutput, context);
+            throw await de_ConflictSourceNamesExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1144,9 +1142,9 @@ const deserializeAws_restJson1DeleteCustomLogSourceCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1DeleteDatalakeCommand = async (output, context) => {
+export const de_DeleteDatalakeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteDatalakeCommandError(output, context);
+        return de_DeleteDatalakeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1154,7 +1152,7 @@ export const deserializeAws_restJson1DeleteDatalakeCommand = async (output, cont
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteDatalakeCommandError = async (output, context) => {
+const de_DeleteDatalakeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1163,25 +1161,25 @@ const deserializeAws_restJson1DeleteDatalakeCommandError = async (output, contex
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.securitylake#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ServiceQuotaExceededException":
         case "com.amazonaws.securitylake#ServiceQuotaExceededException":
-            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.securitylake#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1192,9 +1190,9 @@ const deserializeAws_restJson1DeleteDatalakeCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1DeleteDatalakeAutoEnableCommand = async (output, context) => {
+export const de_DeleteDatalakeAutoEnableCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteDatalakeAutoEnableCommandError(output, context);
+        return de_DeleteDatalakeAutoEnableCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1202,7 +1200,7 @@ export const deserializeAws_restJson1DeleteDatalakeAutoEnableCommand = async (ou
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteDatalakeAutoEnableCommandError = async (output, context) => {
+const de_DeleteDatalakeAutoEnableCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1211,16 +1209,16 @@ const deserializeAws_restJson1DeleteDatalakeAutoEnableCommandError = async (outp
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1231,9 +1229,9 @@ const deserializeAws_restJson1DeleteDatalakeAutoEnableCommandError = async (outp
             });
     }
 };
-export const deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommand = async (output, context) => {
+export const de_DeleteDatalakeDelegatedAdminCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommandError(output, context);
+        return de_DeleteDatalakeDelegatedAdminCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1241,7 +1239,7 @@ export const deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommand = async
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommandError = async (output, context) => {
+const de_DeleteDatalakeDelegatedAdminCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1250,16 +1248,16 @@ const deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommandError = async (
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.securitylake#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1270,9 +1268,9 @@ const deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommandError = async (
             });
     }
 };
-export const deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand = async (output, context) => {
+export const de_DeleteDatalakeExceptionsSubscriptionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommandError(output, context);
+        return de_DeleteDatalakeExceptionsSubscriptionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1283,7 +1281,7 @@ export const deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand
     }
     return contents;
 };
-const deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
+const de_DeleteDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1292,16 +1290,16 @@ const deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommandError =
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1312,9 +1310,9 @@ const deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommandError =
             });
     }
 };
-export const deserializeAws_restJson1DeleteSubscriberCommand = async (output, context) => {
+export const de_DeleteSubscriberCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteSubscriberCommandError(output, context);
+        return de_DeleteSubscriberCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1322,7 +1320,7 @@ export const deserializeAws_restJson1DeleteSubscriberCommand = async (output, co
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteSubscriberCommandError = async (output, context) => {
+const de_DeleteSubscriberCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1331,28 +1329,28 @@ const deserializeAws_restJson1DeleteSubscriberCommandError = async (output, cont
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "BucketNotFoundException":
         case "com.amazonaws.securitylake#BucketNotFoundException":
-            throw await deserializeAws_restJson1BucketNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_BucketNotFoundExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.securitylake#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "InvalidInputException":
         case "com.amazonaws.securitylake#InvalidInputException":
-            throw await deserializeAws_restJson1InvalidInputExceptionResponse(parsedOutput, context);
+            throw await de_InvalidInputExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1363,9 +1361,9 @@ const deserializeAws_restJson1DeleteSubscriberCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand = async (output, context) => {
+export const de_DeleteSubscriptionNotificationConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommandError(output, context);
+        return de_DeleteSubscriptionNotificationConfigurationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1373,7 +1371,7 @@ export const deserializeAws_restJson1DeleteSubscriptionNotificationConfiguration
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommandError = async (output, context) => {
+const de_DeleteSubscriptionNotificationConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1382,25 +1380,25 @@ const deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.securitylake#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "InvalidInputException":
         case "com.amazonaws.securitylake#InvalidInputException":
-            throw await deserializeAws_restJson1InvalidInputExceptionResponse(parsedOutput, context);
+            throw await de_InvalidInputExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1411,20 +1409,20 @@ const deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand
             });
     }
 };
-export const deserializeAws_restJson1GetDatalakeCommand = async (output, context) => {
+export const de_GetDatalakeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetDatalakeCommandError(output, context);
+        return de_GetDatalakeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.configurations != null) {
-        contents.configurations = deserializeAws_restJson1LakeConfigurationResponseMap(data.configurations, context);
+        contents.configurations = de_LakeConfigurationResponseMap(data.configurations, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetDatalakeCommandError = async (output, context) => {
+const de_GetDatalakeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1433,19 +1431,19 @@ const deserializeAws_restJson1GetDatalakeCommandError = async (output, context)
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1456,20 +1454,20 @@ const deserializeAws_restJson1GetDatalakeCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_restJson1GetDatalakeAutoEnableCommand = async (output, context) => {
+export const de_GetDatalakeAutoEnableCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetDatalakeAutoEnableCommandError(output, context);
+        return de_GetDatalakeAutoEnableCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.autoEnableNewAccounts != null) {
-        contents.autoEnableNewAccounts = deserializeAws_restJson1AutoEnableNewRegionConfigurationList(data.autoEnableNewAccounts, context);
+        contents.autoEnableNewAccounts = de_AutoEnableNewRegionConfigurationList(data.autoEnableNewAccounts, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetDatalakeAutoEnableCommandError = async (output, context) => {
+const de_GetDatalakeAutoEnableCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1478,16 +1476,16 @@ const deserializeAws_restJson1GetDatalakeAutoEnableCommandError = async (output,
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1498,9 +1496,9 @@ const deserializeAws_restJson1GetDatalakeAutoEnableCommandError = async (output,
             });
     }
 };
-export const deserializeAws_restJson1GetDatalakeExceptionsExpiryCommand = async (output, context) => {
+export const de_GetDatalakeExceptionsExpiryCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetDatalakeExceptionsExpiryCommandError(output, context);
+        return de_GetDatalakeExceptionsExpiryCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1511,7 +1509,7 @@ export const deserializeAws_restJson1GetDatalakeExceptionsExpiryCommand = async
     }
     return contents;
 };
-const deserializeAws_restJson1GetDatalakeExceptionsExpiryCommandError = async (output, context) => {
+const de_GetDatalakeExceptionsExpiryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1520,16 +1518,16 @@ const deserializeAws_restJson1GetDatalakeExceptionsExpiryCommandError = async (o
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1540,20 +1538,20 @@ const deserializeAws_restJson1GetDatalakeExceptionsExpiryCommandError = async (o
             });
     }
 };
-export const deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand = async (output, context) => {
+export const de_GetDatalakeExceptionsSubscriptionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommandError(output, context);
+        return de_GetDatalakeExceptionsSubscriptionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.protocolAndNotificationEndpoint != null) {
-        contents.protocolAndNotificationEndpoint = deserializeAws_restJson1ProtocolAndNotificationEndpoint(data.protocolAndNotificationEndpoint, context);
+        contents.protocolAndNotificationEndpoint = de_ProtocolAndNotificationEndpoint(data.protocolAndNotificationEndpoint, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
+const de_GetDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1562,16 +1560,16 @@ const deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommandError = as
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1582,23 +1580,23 @@ const deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommandError = as
             });
     }
 };
-export const deserializeAws_restJson1GetDatalakeStatusCommand = async (output, context) => {
+export const de_GetDatalakeStatusCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetDatalakeStatusCommandError(output, context);
+        return de_GetDatalakeStatusCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.accountSourcesList != null) {
-        contents.accountSourcesList = deserializeAws_restJson1AccountSourcesList(data.accountSourcesList, context);
+        contents.accountSourcesList = de_AccountSourcesList(data.accountSourcesList, context);
     }
     if (data.nextToken != null) {
         contents.nextToken = __expectString(data.nextToken);
     }
     return contents;
 };
-const deserializeAws_restJson1GetDatalakeStatusCommandError = async (output, context) => {
+const de_GetDatalakeStatusCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1607,16 +1605,16 @@ const deserializeAws_restJson1GetDatalakeStatusCommandError = async (output, con
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1627,20 +1625,20 @@ const deserializeAws_restJson1GetDatalakeStatusCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1GetSubscriberCommand = async (output, context) => {
+export const de_GetSubscriberCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetSubscriberCommandError(output, context);
+        return de_GetSubscriberCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.subscriber != null) {
-        contents.subscriber = deserializeAws_restJson1SubscriberResource(data.subscriber, context);
+        contents.subscriber = de_SubscriberResource(data.subscriber, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetSubscriberCommandError = async (output, context) => {
+const de_GetSubscriberCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1649,19 +1647,19 @@ const deserializeAws_restJson1GetSubscriberCommandError = async (output, context
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "InvalidInputException":
         case "com.amazonaws.securitylake#InvalidInputException":
-            throw await deserializeAws_restJson1InvalidInputExceptionResponse(parsedOutput, context);
+            throw await de_InvalidInputExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1672,9 +1670,9 @@ const deserializeAws_restJson1GetSubscriberCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1ListDatalakeExceptionsCommand = async (output, context) => {
+export const de_ListDatalakeExceptionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListDatalakeExceptionsCommandError(output, context);
+        return de_ListDatalakeExceptionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1684,11 +1682,11 @@ export const deserializeAws_restJson1ListDatalakeExceptionsCommand = async (outp
         contents.nextToken = __expectString(data.nextToken);
     }
     if (data.nonRetryableFailures != null) {
-        contents.nonRetryableFailures = deserializeAws_restJson1FailuresResponseList(data.nonRetryableFailures, context);
+        contents.nonRetryableFailures = de_FailuresResponseList(data.nonRetryableFailures, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListDatalakeExceptionsCommandError = async (output, context) => {
+const de_ListDatalakeExceptionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1697,16 +1695,16 @@ const deserializeAws_restJson1ListDatalakeExceptionsCommandError = async (output
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1717,9 +1715,9 @@ const deserializeAws_restJson1ListDatalakeExceptionsCommandError = async (output
             });
     }
 };
-export const deserializeAws_restJson1ListLogSourcesCommand = async (output, context) => {
+export const de_ListLogSourcesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListLogSourcesCommandError(output, context);
+        return de_ListLogSourcesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1729,11 +1727,11 @@ export const deserializeAws_restJson1ListLogSourcesCommand = async (output, cont
         contents.nextToken = __expectString(data.nextToken);
     }
     if (data.regionSourceTypesAccountsList != null) {
-        contents.regionSourceTypesAccountsList = deserializeAws_restJson1RegionSourceTypesAccountsList(data.regionSourceTypesAccountsList, context);
+        contents.regionSourceTypesAccountsList = de_RegionSourceTypesAccountsList(data.regionSourceTypesAccountsList, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListLogSourcesCommandError = async (output, context) => {
+const de_ListLogSourcesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1742,19 +1740,19 @@ const deserializeAws_restJson1ListLogSourcesCommandError = async (output, contex
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1765,9 +1763,9 @@ const deserializeAws_restJson1ListLogSourcesCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1ListSubscribersCommand = async (output, context) => {
+export const de_ListSubscribersCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListSubscribersCommandError(output, context);
+        return de_ListSubscribersCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1777,11 +1775,11 @@ export const deserializeAws_restJson1ListSubscribersCommand = async (output, con
         contents.nextToken = __expectString(data.nextToken);
     }
     if (data.subscribers != null) {
-        contents.subscribers = deserializeAws_restJson1SubscriberList(data.subscribers, context);
+        contents.subscribers = de_SubscriberList(data.subscribers, context);
     }
     return contents;
 };
-const deserializeAws_restJson1ListSubscribersCommandError = async (output, context) => {
+const de_ListSubscribersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1790,22 +1788,22 @@ const deserializeAws_restJson1ListSubscribersCommandError = async (output, conte
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "InvalidInputException":
         case "com.amazonaws.securitylake#InvalidInputException":
-            throw await deserializeAws_restJson1InvalidInputExceptionResponse(parsedOutput, context);
+            throw await de_InvalidInputExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1816,9 +1814,9 @@ const deserializeAws_restJson1ListSubscribersCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_restJson1UpdateDatalakeCommand = async (output, context) => {
+export const de_UpdateDatalakeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateDatalakeCommandError(output, context);
+        return de_UpdateDatalakeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1826,7 +1824,7 @@ export const deserializeAws_restJson1UpdateDatalakeCommand = async (output, cont
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1UpdateDatalakeCommandError = async (output, context) => {
+const de_UpdateDatalakeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1835,19 +1833,19 @@ const deserializeAws_restJson1UpdateDatalakeCommandError = async (output, contex
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "EventBridgeException":
         case "com.amazonaws.securitylake#EventBridgeException":
-            throw await deserializeAws_restJson1EventBridgeExceptionResponse(parsedOutput, context);
+            throw await de_EventBridgeExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1858,9 +1856,9 @@ const deserializeAws_restJson1UpdateDatalakeCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand = async (output, context) => {
+export const de_UpdateDatalakeExceptionsExpiryCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommandError(output, context);
+        return de_UpdateDatalakeExceptionsExpiryCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1868,7 +1866,7 @@ export const deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand = asy
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommandError = async (output, context) => {
+const de_UpdateDatalakeExceptionsExpiryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1877,16 +1875,16 @@ const deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommandError = async
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1897,9 +1895,9 @@ const deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommandError = async
             });
     }
 };
-export const deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand = async (output, context) => {
+export const de_UpdateDatalakeExceptionsSubscriptionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommandError(output, context);
+        return de_UpdateDatalakeExceptionsSubscriptionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1907,7 +1905,7 @@ export const deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand
     await collectBody(output.body, context);
     return contents;
 };
-const deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
+const de_UpdateDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1916,16 +1914,16 @@ const deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommandError =
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1936,20 +1934,20 @@ const deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommandError =
             });
     }
 };
-export const deserializeAws_restJson1UpdateSubscriberCommand = async (output, context) => {
+export const de_UpdateSubscriberCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateSubscriberCommandError(output, context);
+        return de_UpdateSubscriberCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.subscriber != null) {
-        contents.subscriber = deserializeAws_restJson1SubscriberResource(data.subscriber, context);
+        contents.subscriber = de_SubscriberResource(data.subscriber, context);
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateSubscriberCommandError = async (output, context) => {
+const de_UpdateSubscriberCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1958,25 +1956,25 @@ const deserializeAws_restJson1UpdateSubscriberCommandError = async (output, cont
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.securitylake#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "ConflictSubscriptionException":
         case "com.amazonaws.securitylake#ConflictSubscriptionException":
-            throw await deserializeAws_restJson1ConflictSubscriptionExceptionResponse(parsedOutput, context);
+            throw await de_ConflictSubscriptionExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "InvalidInputException":
         case "com.amazonaws.securitylake#InvalidInputException":
-            throw await deserializeAws_restJson1InvalidInputExceptionResponse(parsedOutput, context);
+            throw await de_InvalidInputExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1987,9 +1985,9 @@ const deserializeAws_restJson1UpdateSubscriberCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand = async (output, context) => {
+export const de_UpdateSubscriptionNotificationConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommandError(output, context);
+        return de_UpdateSubscriptionNotificationConfigurationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2000,7 +1998,7 @@ export const deserializeAws_restJson1UpdateSubscriptionNotificationConfiguration
     }
     return contents;
 };
-const deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommandError = async (output, context) => {
+const de_UpdateSubscriptionNotificationConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2009,25 +2007,25 @@ const deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "AccountNotFoundException":
         case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
         case "ConcurrentModificationException":
         case "com.amazonaws.securitylake#ConcurrentModificationException":
-            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "InvalidInputException":
         case "com.amazonaws.securitylake#InvalidInputException":
-            throw await deserializeAws_restJson1InvalidInputExceptionResponse(parsedOutput, context);
+            throw await de_InvalidInputExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.securitylake#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -2039,7 +2037,7 @@ const deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand
     }
 };
 const map = __map;
-const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
+const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.errorCode != null) {
@@ -2054,7 +2052,7 @@ const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutpu
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1AccountNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_AccountNotFoundExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2066,7 +2064,7 @@ const deserializeAws_restJson1AccountNotFoundExceptionResponse = async (parsedOu
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1BucketNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_BucketNotFoundExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2078,7 +2076,7 @@ const deserializeAws_restJson1BucketNotFoundExceptionResponse = async (parsedOut
     });
     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) {
@@ -2090,7 +2088,7 @@ const deserializeAws_restJson1ConcurrentModificationExceptionResponse = async (p
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
+const de_ConflictExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2108,7 +2106,7 @@ const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, c
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ConflictSourceNamesExceptionResponse = async (parsedOutput, context) => {
+const de_ConflictSourceNamesExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2120,7 +2118,7 @@ const deserializeAws_restJson1ConflictSourceNamesExceptionResponse = async (pars
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ConflictSubscriptionExceptionResponse = async (parsedOutput, context) => {
+const de_ConflictSubscriptionExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2132,7 +2130,7 @@ const deserializeAws_restJson1ConflictSubscriptionExceptionResponse = async (par
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1EventBridgeExceptionResponse = async (parsedOutput, context) => {
+const de_EventBridgeExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2144,7 +2142,7 @@ const deserializeAws_restJson1EventBridgeExceptionResponse = async (parsedOutput
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOutput, context) => {
+const de_InternalServerExceptionRes = async (parsedOutput, context) => {
     const contents = map({
         retryAfterSeconds: [
             () => void 0 !== parsedOutput.headers["retry-after"],
@@ -2161,7 +2159,7 @@ const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOut
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1InvalidInputExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidInputExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2173,7 +2171,7 @@ const deserializeAws_restJson1InvalidInputExceptionResponse = async (parsedOutpu
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2191,7 +2189,7 @@ const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedO
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1S3ExceptionResponse = async (parsedOutput, context) => {
+const de_S3ExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2203,7 +2201,7 @@ const deserializeAws_restJson1S3ExceptionResponse = async (parsedOutput, context
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ServiceQuotaExceededExceptionResponse = async (parsedOutput, context) => {
+const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -2227,7 +2225,7 @@ const deserializeAws_restJson1ServiceQuotaExceededExceptionResponse = async (par
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput, context) => {
+const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
     const contents = map({
         retryAfterSeconds: [
             () => void 0 !== parsedOutput.headers["retry-after"],
@@ -2250,11 +2248,11 @@ const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput, context) => {
+const de_ValidationExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.fieldList != null) {
-        contents.fieldList = deserializeAws_restJson1ValidationExceptionFieldList(data.fieldList, context);
+        contents.fieldList = de_ValidationExceptionFieldList(data.fieldList, context);
     }
     if (data.message != null) {
         contents.message = __expectString(data.message);
@@ -2268,113 +2266,113 @@ const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const serializeAws_restJson1AccessTypeList = (input, context) => {
+const se_AccessTypeList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1AllDimensionsMap = (input, context) => {
+const se_AllDimensionsMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = serializeAws_restJson1TwoDimensionsMap(value, context);
+        acc[key] = se_TwoDimensionsMap(value, context);
         return acc;
     }, {});
 };
-const serializeAws_restJson1AutoEnableNewRegionConfiguration = (input, context) => {
+const se_AutoEnableNewRegionConfiguration = (input, context) => {
     return {
         ...(input.region != null && { region: input.region }),
-        ...(input.sources != null && { sources: serializeAws_restJson1AwsSourceTypeList(input.sources, context) }),
+        ...(input.sources != null && { sources: se_AwsSourceTypeList(input.sources, context) }),
     };
 };
-const serializeAws_restJson1AutoEnableNewRegionConfigurationList = (input, context) => {
+const se_AutoEnableNewRegionConfigurationList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1AutoEnableNewRegionConfiguration(entry, context);
+        return se_AutoEnableNewRegionConfiguration(entry, context);
     });
 };
-const serializeAws_restJson1AwsSourceTypeList = (input, context) => {
+const se_AwsSourceTypeList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1DimensionSet = (input, context) => {
+const se_DimensionSet = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1InputSet = (input, context) => {
+const se_InputSet = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1LakeConfigurationRequest = (input, context) => {
+const se_LakeConfigurationRequest = (input, context) => {
     return {
         ...(input.encryptionKey != null && { encryptionKey: input.encryptionKey }),
         ...(input.replicationDestinationRegions != null && {
-            replicationDestinationRegions: serializeAws_restJson1RegionSet(input.replicationDestinationRegions, context),
+            replicationDestinationRegions: se_RegionSet(input.replicationDestinationRegions, context),
         }),
         ...(input.replicationRoleArn != null && { replicationRoleArn: input.replicationRoleArn }),
         ...(input.retentionSettings != null && {
-            retentionSettings: serializeAws_restJson1RetentionSettingList(input.retentionSettings, context),
+            retentionSettings: se_RetentionSettingList(input.retentionSettings, context),
         }),
-        ...(input.tagsMap != null && { tagsMap: serializeAws_restJson1TagsMap(input.tagsMap, context) }),
+        ...(input.tagsMap != null && { tagsMap: se_TagsMap(input.tagsMap, context) }),
     };
 };
-const serializeAws_restJson1LakeConfigurationRequestMap = (input, context) => {
+const se_LakeConfigurationRequestMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = serializeAws_restJson1LakeConfigurationRequest(value, context);
+        acc[key] = se_LakeConfigurationRequest(value, context);
         return acc;
     }, {});
 };
-const serializeAws_restJson1RegionSet = (input, context) => {
+const se_RegionSet = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1RetentionSetting = (input, context) => {
+const se_RetentionSetting = (input, context) => {
     return {
         ...(input.retentionPeriod != null && { retentionPeriod: input.retentionPeriod }),
         ...(input.storageClass != null && { storageClass: input.storageClass }),
     };
 };
-const serializeAws_restJson1RetentionSettingList = (input, context) => {
+const se_RetentionSettingList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1RetentionSetting(entry, context);
+        return se_RetentionSetting(entry, context);
     });
 };
-const serializeAws_restJson1SourceType = (input, context) => {
+const se_SourceType = (input, context) => {
     return SourceType.visit(input, {
         awsSourceType: (value) => ({ awsSourceType: value }),
         customSourceType: (value) => ({ customSourceType: value }),
         _: (name, value) => ({ name: value }),
     });
 };
-const serializeAws_restJson1SourceTypeList = (input, context) => {
+const se_SourceTypeList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1SourceType(entry, context);
+        return se_SourceType(entry, context);
     });
 };
-const serializeAws_restJson1TagsMap = (input, context) => {
+const se_TagsMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -2383,23 +2381,23 @@ const serializeAws_restJson1TagsMap = (input, context) => {
         return acc;
     }, {});
 };
-const serializeAws_restJson1TwoDimensionsMap = (input, context) => {
+const se_TwoDimensionsMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = serializeAws_restJson1ValueSet(value, context);
+        acc[key] = se_ValueSet(value, context);
         return acc;
     }, {});
 };
-const serializeAws_restJson1ValueSet = (input, context) => {
+const se_ValueSet = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const deserializeAws_restJson1AccessTypeList = (output, context) => {
+const de_AccessTypeList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2410,7 +2408,7 @@ const deserializeAws_restJson1AccessTypeList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1AccountList = (output, context) => {
+const de_AccountList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2421,52 +2419,52 @@ const deserializeAws_restJson1AccountList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1AccountSources = (output, context) => {
+const de_AccountSources = (output, context) => {
     return {
         account: __expectString(output.account),
         eventClass: __expectString(output.eventClass),
-        logsStatus: output.logsStatus != null ? deserializeAws_restJson1LogsStatusList(output.logsStatus, context) : undefined,
+        logsStatus: output.logsStatus != null ? de_LogsStatusList(output.logsStatus, context) : undefined,
         sourceType: __expectString(output.sourceType),
     };
 };
-const deserializeAws_restJson1AccountSourcesList = (output, context) => {
+const de_AccountSourcesList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AccountSources(entry, context);
+        return de_AccountSources(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AllDimensionsMap = (output, context) => {
+const de_AllDimensionsMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = deserializeAws_restJson1TwoDimensionsMap(value, context);
+        acc[key] = de_TwoDimensionsMap(value, context);
         return acc;
     }, {});
 };
-const deserializeAws_restJson1AutoEnableNewRegionConfiguration = (output, context) => {
+const de_AutoEnableNewRegionConfiguration = (output, context) => {
     return {
         region: __expectString(output.region),
-        sources: output.sources != null ? deserializeAws_restJson1AwsSourceTypeList(output.sources, context) : undefined,
+        sources: output.sources != null ? de_AwsSourceTypeList(output.sources, context) : undefined,
     };
 };
-const deserializeAws_restJson1AutoEnableNewRegionConfigurationList = (output, context) => {
+const de_AutoEnableNewRegionConfigurationList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AutoEnableNewRegionConfiguration(entry, context);
+        return de_AutoEnableNewRegionConfiguration(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1AwsSourceTypeList = (output, context) => {
+const de_AwsSourceTypeList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2477,96 +2475,94 @@ const deserializeAws_restJson1AwsSourceTypeList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1Failures = (output, context) => {
+const de_Failures = (output, context) => {
     return {
         exceptionMessage: __expectString(output.exceptionMessage),
         remediation: __expectString(output.remediation),
         timestamp: output.timestamp != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.timestamp)) : undefined,
     };
 };
-const deserializeAws_restJson1Failureslist = (output, context) => {
+const de_Failureslist = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Failures(entry, context);
+        return de_Failures(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1FailuresResponse = (output, context) => {
+const de_FailuresResponse = (output, context) => {
     return {
-        failures: output.failures != null ? deserializeAws_restJson1Failureslist(output.failures, context) : undefined,
+        failures: output.failures != null ? de_Failureslist(output.failures, context) : undefined,
         region: __expectString(output.region),
     };
 };
-const deserializeAws_restJson1FailuresResponseList = (output, context) => {
+const de_FailuresResponseList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1FailuresResponse(entry, context);
+        return de_FailuresResponse(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1LakeConfigurationResponse = (output, context) => {
+const de_LakeConfigurationResponse = (output, context) => {
     return {
         encryptionKey: __expectString(output.encryptionKey),
         replicationDestinationRegions: output.replicationDestinationRegions != null
-            ? deserializeAws_restJson1RegionSet(output.replicationDestinationRegions, context)
+            ? de_RegionSet(output.replicationDestinationRegions, context)
             : undefined,
         replicationRoleArn: __expectString(output.replicationRoleArn),
-        retentionSettings: output.retentionSettings != null
-            ? deserializeAws_restJson1RetentionSettingList(output.retentionSettings, context)
-            : undefined,
+        retentionSettings: output.retentionSettings != null ? de_RetentionSettingList(output.retentionSettings, context) : undefined,
         s3BucketArn: __expectString(output.s3BucketArn),
         status: __expectString(output.status),
-        tagsMap: output.tagsMap != null ? deserializeAws_restJson1TagsMap(output.tagsMap, context) : undefined,
-        updateStatus: output.updateStatus != null ? deserializeAws_restJson1UpdateStatus(output.updateStatus, context) : undefined,
+        tagsMap: output.tagsMap != null ? de_TagsMap(output.tagsMap, context) : undefined,
+        updateStatus: output.updateStatus != null ? de_UpdateStatus(output.updateStatus, context) : undefined,
     };
 };
-const deserializeAws_restJson1LakeConfigurationResponseMap = (output, context) => {
+const de_LakeConfigurationResponseMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = deserializeAws_restJson1LakeConfigurationResponse(value, context);
+        acc[key] = de_LakeConfigurationResponse(value, context);
         return acc;
     }, {});
 };
-const deserializeAws_restJson1LastUpdateFailure = (output, context) => {
+const de_LastUpdateFailure = (output, context) => {
     return {
         code: __expectString(output.code),
         reason: __expectString(output.reason),
     };
 };
-const deserializeAws_restJson1LogsStatus = (output, context) => {
+const de_LogsStatus = (output, context) => {
     return {
         healthStatus: __expectString(output.healthStatus),
         pathToLogs: __expectString(output.pathToLogs),
     };
 };
-const deserializeAws_restJson1LogsStatusList = (output, context) => {
+const de_LogsStatusList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1LogsStatus(entry, context);
+        return de_LogsStatus(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ProtocolAndNotificationEndpoint = (output, context) => {
+const de_ProtocolAndNotificationEndpoint = (output, context) => {
     return {
         endpoint: __expectString(output.endpoint),
         protocol: __expectString(output.protocol),
     };
 };
-const deserializeAws_restJson1RegionSet = (output, context) => {
+const de_RegionSet = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2577,35 +2573,35 @@ const deserializeAws_restJson1RegionSet = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1RegionSourceTypesAccountsList = (output, context) => {
+const de_RegionSourceTypesAccountsList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1AllDimensionsMap(entry, context);
+        return de_AllDimensionsMap(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1RetentionSetting = (output, context) => {
+const de_RetentionSetting = (output, context) => {
     return {
         retentionPeriod: __expectInt32(output.retentionPeriod),
         storageClass: __expectString(output.storageClass),
     };
 };
-const deserializeAws_restJson1RetentionSettingList = (output, context) => {
+const de_RetentionSettingList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1RetentionSetting(entry, context);
+        return de_RetentionSetting(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1SourceType = (output, context) => {
+const de_SourceType = (output, context) => {
     if (__expectString(output.awsSourceType) !== undefined) {
         return { awsSourceType: __expectString(output.awsSourceType) };
     }
@@ -2614,31 +2610,31 @@ const deserializeAws_restJson1SourceType = (output, context) => {
     }
     return { $unknown: Object.entries(output)[0] };
 };
-const deserializeAws_restJson1SourceTypeList = (output, context) => {
+const de_SourceTypeList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1SourceType(__expectUnion(entry), context);
+        return de_SourceType(__expectUnion(entry), context);
     });
     return retVal;
 };
-const deserializeAws_restJson1SubscriberList = (output, context) => {
+const de_SubscriberList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1SubscriberResource(entry, context);
+        return de_SubscriberResource(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1SubscriberResource = (output, context) => {
+const de_SubscriberResource = (output, context) => {
     return {
-        accessTypes: output.accessTypes != null ? deserializeAws_restJson1AccessTypeList(output.accessTypes, context) : undefined,
+        accessTypes: output.accessTypes != null ? de_AccessTypeList(output.accessTypes, context) : undefined,
         accountId: __expectString(output.accountId),
         createdAt: output.createdAt != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.createdAt)) : undefined,
         externalId: __expectString(output.externalId),
@@ -2647,7 +2643,7 @@ const deserializeAws_restJson1SubscriberResource = (output, context) => {
         roleArn: __expectString(output.roleArn),
         s3BucketArn: __expectString(output.s3BucketArn),
         snsArn: __expectString(output.snsArn),
-        sourceTypes: output.sourceTypes != null ? deserializeAws_restJson1SourceTypeList(output.sourceTypes, context) : undefined,
+        sourceTypes: output.sourceTypes != null ? de_SourceTypeList(output.sourceTypes, context) : undefined,
         subscriberDescription: __expectString(output.subscriberDescription),
         subscriberName: __expectString(output.subscriberName),
         subscriptionEndpoint: __expectString(output.subscriptionEndpoint),
@@ -2657,7 +2653,7 @@ const deserializeAws_restJson1SubscriberResource = (output, context) => {
         updatedAt: output.updatedAt != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.updatedAt)) : undefined,
     };
 };
-const deserializeAws_restJson1TagsMap = (output, context) => {
+const de_TagsMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -2666,42 +2662,40 @@ const deserializeAws_restJson1TagsMap = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_restJson1TwoDimensionsMap = (output, context) => {
+const de_TwoDimensionsMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = deserializeAws_restJson1ValueSet(value, context);
+        acc[key] = de_ValueSet(value, context);
         return acc;
     }, {});
 };
-const deserializeAws_restJson1UpdateStatus = (output, context) => {
+const de_UpdateStatus = (output, context) => {
     return {
-        lastUpdateFailure: output.lastUpdateFailure != null
-            ? deserializeAws_restJson1LastUpdateFailure(output.lastUpdateFailure, context)
-            : undefined,
+        lastUpdateFailure: output.lastUpdateFailure != null ? de_LastUpdateFailure(output.lastUpdateFailure, context) : undefined,
         lastUpdateRequestId: __expectString(output.lastUpdateRequestId),
         lastUpdateStatus: __expectString(output.lastUpdateStatus),
     };
 };
-const deserializeAws_restJson1ValidationExceptionField = (output, context) => {
+const de_ValidationExceptionField = (output, context) => {
     return {
         message: __expectString(output.message),
         name: __expectString(output.name),
     };
 };
-const deserializeAws_restJson1ValidationExceptionFieldList = (output, context) => {
+const de_ValidationExceptionFieldList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ValidationExceptionField(entry, context);
+        return de_ValidationExceptionField(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ValueSet = (output, context) => {
+const de_ValueSet = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {