@aws-sdk/client-securitylake 3.306.0 → 3.310.0

package/dist-cjs/protocols/Aws_restJson1.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand = exports.deserializeAws_restJson1GetDatalakeExceptionsExpiryCommand = exports.deserializeAws_restJson1GetDatalakeAutoEnableCommand = exports.deserializeAws_restJson1GetDatalakeCommand = exports.deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand = exports.deserializeAws_restJson1DeleteSubscriberCommand = exports.deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand = exports.deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommand = exports.deserializeAws_restJson1DeleteDatalakeAutoEnableCommand = exports.deserializeAws_restJson1DeleteDatalakeCommand = exports.deserializeAws_restJson1DeleteCustomLogSourceCommand = exports.deserializeAws_restJson1DeleteAwsLogSourceCommand = exports.deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand = exports.deserializeAws_restJson1CreateSubscriberCommand = exports.deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand = exports.deserializeAws_restJson1CreateDatalakeDelegatedAdminCommand = exports.deserializeAws_restJson1CreateDatalakeAutoEnableCommand = exports.deserializeAws_restJson1CreateDatalakeCommand = exports.deserializeAws_restJson1CreateCustomLogSourceCommand = exports.deserializeAws_restJson1CreateAwsLogSourceCommand = exports.serializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand = exports.serializeAws_restJson1UpdateSubscriberCommand = exports.serializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand = exports.serializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand = exports.serializeAws_restJson1UpdateDatalakeCommand = exports.serializeAws_restJson1ListSubscribersCommand = exports.serializeAws_restJson1ListLogSourcesCommand = exports.serializeAws_restJson1ListDatalakeExceptionsCommand = exports.serializeAws_restJson1GetSubscriberCommand = exports.serializeAws_restJson1GetDatalakeStatusCommand = exports.serializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand = exports.serializeAws_restJson1GetDatalakeExceptionsExpiryCommand = exports.serializeAws_restJson1GetDatalakeAutoEnableCommand = exports.serializeAws_restJson1GetDatalakeCommand = exports.serializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand = exports.serializeAws_restJson1DeleteSubscriberCommand = exports.serializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand = exports.serializeAws_restJson1DeleteDatalakeDelegatedAdminCommand = exports.serializeAws_restJson1DeleteDatalakeAutoEnableCommand = exports.serializeAws_restJson1DeleteDatalakeCommand = exports.serializeAws_restJson1DeleteCustomLogSourceCommand = exports.serializeAws_restJson1DeleteAwsLogSourceCommand = exports.serializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand = exports.serializeAws_restJson1CreateSubscriberCommand = exports.serializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand = exports.serializeAws_restJson1CreateDatalakeDelegatedAdminCommand = exports.serializeAws_restJson1CreateDatalakeAutoEnableCommand = exports.serializeAws_restJson1CreateDatalakeCommand = exports.serializeAws_restJson1CreateCustomLogSourceCommand = exports.serializeAws_restJson1CreateAwsLogSourceCommand = void 0;
-exports.deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand = exports.deserializeAws_restJson1UpdateSubscriberCommand = exports.deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand = exports.deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand = exports.deserializeAws_restJson1UpdateDatalakeCommand = exports.deserializeAws_restJson1ListSubscribersCommand = exports.deserializeAws_restJson1ListLogSourcesCommand = exports.deserializeAws_restJson1ListDatalakeExceptionsCommand = exports.deserializeAws_restJson1GetSubscriberCommand = exports.deserializeAws_restJson1GetDatalakeStatusCommand = void 0;
+exports.de_GetDatalakeExceptionsSubscriptionCommand = exports.de_GetDatalakeExceptionsExpiryCommand = exports.de_GetDatalakeAutoEnableCommand = exports.de_GetDatalakeCommand = exports.de_DeleteSubscriptionNotificationConfigurationCommand = exports.de_DeleteSubscriberCommand = exports.de_DeleteDatalakeExceptionsSubscriptionCommand = exports.de_DeleteDatalakeDelegatedAdminCommand = exports.de_DeleteDatalakeAutoEnableCommand = exports.de_DeleteDatalakeCommand = exports.de_DeleteCustomLogSourceCommand = exports.de_DeleteAwsLogSourceCommand = exports.de_CreateSubscriptionNotificationConfigurationCommand = exports.de_CreateSubscriberCommand = exports.de_CreateDatalakeExceptionsSubscriptionCommand = exports.de_CreateDatalakeDelegatedAdminCommand = exports.de_CreateDatalakeAutoEnableCommand = exports.de_CreateDatalakeCommand = exports.de_CreateCustomLogSourceCommand = exports.de_CreateAwsLogSourceCommand = exports.se_UpdateSubscriptionNotificationConfigurationCommand = exports.se_UpdateSubscriberCommand = exports.se_UpdateDatalakeExceptionsSubscriptionCommand = exports.se_UpdateDatalakeExceptionsExpiryCommand = exports.se_UpdateDatalakeCommand = exports.se_ListSubscribersCommand = exports.se_ListLogSourcesCommand = exports.se_ListDatalakeExceptionsCommand = exports.se_GetSubscriberCommand = exports.se_GetDatalakeStatusCommand = exports.se_GetDatalakeExceptionsSubscriptionCommand = exports.se_GetDatalakeExceptionsExpiryCommand = exports.se_GetDatalakeAutoEnableCommand = exports.se_GetDatalakeCommand = exports.se_DeleteSubscriptionNotificationConfigurationCommand = exports.se_DeleteSubscriberCommand = exports.se_DeleteDatalakeExceptionsSubscriptionCommand = exports.se_DeleteDatalakeDelegatedAdminCommand = exports.se_DeleteDatalakeAutoEnableCommand = exports.se_DeleteDatalakeCommand = exports.se_DeleteCustomLogSourceCommand = exports.se_DeleteAwsLogSourceCommand = exports.se_CreateSubscriptionNotificationConfigurationCommand = exports.se_CreateSubscriberCommand = exports.se_CreateDatalakeExceptionsSubscriptionCommand = exports.se_CreateDatalakeDelegatedAdminCommand = exports.se_CreateDatalakeAutoEnableCommand = exports.se_CreateDatalakeCommand = exports.se_CreateCustomLogSourceCommand = exports.se_CreateAwsLogSourceCommand = void 0;
+exports.de_UpdateSubscriptionNotificationConfigurationCommand = exports.de_UpdateSubscriberCommand = exports.de_UpdateDatalakeExceptionsSubscriptionCommand = exports.de_UpdateDatalakeExceptionsExpiryCommand = exports.de_UpdateDatalakeCommand = exports.de_ListSubscribersCommand = exports.de_ListLogSourcesCommand = exports.de_ListDatalakeExceptionsCommand = exports.de_GetSubscriberCommand = exports.de_GetDatalakeStatusCommand = void 0;
 const protocol_http_1 = require("@aws-sdk/protocol-http");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const SecurityLakeServiceException_1 = require("../models/SecurityLakeServiceException");
-const serializeAws_restJson1CreateAwsLogSourceCommand = async (input, context) => {
+const se_CreateAwsLogSourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -15,15 +15,15 @@ const serializeAws_restJson1CreateAwsLogSourceCommand = async (input, context) =
     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 protocol_http_1.HttpRequest({
         protocol,
@@ -35,8 +35,8 @@ const serializeAws_restJson1CreateAwsLogSourceCommand = async (input, context) =
         body,
     });
 };
-exports.serializeAws_restJson1CreateAwsLogSourceCommand = serializeAws_restJson1CreateAwsLogSourceCommand;
-const serializeAws_restJson1CreateCustomLogSourceCommand = async (input, context) => {
+exports.se_CreateAwsLogSourceCommand = se_CreateAwsLogSourceCommand;
+const se_CreateCustomLogSourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -59,8 +59,8 @@ const serializeAws_restJson1CreateCustomLogSourceCommand = async (input, context
         body,
     });
 };
-exports.serializeAws_restJson1CreateCustomLogSourceCommand = serializeAws_restJson1CreateCustomLogSourceCommand;
-const serializeAws_restJson1CreateDatalakeCommand = async (input, context) => {
+exports.se_CreateCustomLogSourceCommand = se_CreateCustomLogSourceCommand;
+const se_CreateDatalakeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -69,11 +69,11 @@ 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 protocol_http_1.HttpRequest({
         protocol,
@@ -85,8 +85,8 @@ const serializeAws_restJson1CreateDatalakeCommand = async (input, context) => {
         body,
     });
 };
-exports.serializeAws_restJson1CreateDatalakeCommand = serializeAws_restJson1CreateDatalakeCommand;
-const serializeAws_restJson1CreateDatalakeAutoEnableCommand = async (input, context) => {
+exports.se_CreateDatalakeCommand = se_CreateDatalakeCommand;
+const se_CreateDatalakeAutoEnableCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -95,7 +95,7 @@ const serializeAws_restJson1CreateDatalakeAutoEnableCommand = async (input, cont
     let body;
     body = JSON.stringify({
         ...(input.configurationForNewAccounts != null && {
-            configurationForNewAccounts: serializeAws_restJson1AutoEnableNewRegionConfigurationList(input.configurationForNewAccounts, context),
+            configurationForNewAccounts: se_AutoEnableNewRegionConfigurationList(input.configurationForNewAccounts, context),
         }),
     });
     return new protocol_http_1.HttpRequest({
@@ -108,8 +108,8 @@ const serializeAws_restJson1CreateDatalakeAutoEnableCommand = async (input, cont
         body,
     });
 };
-exports.serializeAws_restJson1CreateDatalakeAutoEnableCommand = serializeAws_restJson1CreateDatalakeAutoEnableCommand;
-const serializeAws_restJson1CreateDatalakeDelegatedAdminCommand = async (input, context) => {
+exports.se_CreateDatalakeAutoEnableCommand = se_CreateDatalakeAutoEnableCommand;
+const se_CreateDatalakeDelegatedAdminCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -129,8 +129,8 @@ const serializeAws_restJson1CreateDatalakeDelegatedAdminCommand = async (input,
         body,
     });
 };
-exports.serializeAws_restJson1CreateDatalakeDelegatedAdminCommand = serializeAws_restJson1CreateDatalakeDelegatedAdminCommand;
-const serializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand = async (input, context) => {
+exports.se_CreateDatalakeDelegatedAdminCommand = se_CreateDatalakeDelegatedAdminCommand;
+const se_CreateDatalakeExceptionsSubscriptionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -151,8 +151,8 @@ const serializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand = async
         body,
     });
 };
-exports.serializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand = serializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand;
-const serializeAws_restJson1CreateSubscriberCommand = async (input, context) => {
+exports.se_CreateDatalakeExceptionsSubscriptionCommand = se_CreateDatalakeExceptionsSubscriptionCommand;
+const se_CreateSubscriberCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -160,10 +160,10 @@ const serializeAws_restJson1CreateSubscriberCommand = async (input, context) =>
     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 }),
     });
@@ -177,8 +177,8 @@ const serializeAws_restJson1CreateSubscriberCommand = async (input, context) =>
         body,
     });
 };
-exports.serializeAws_restJson1CreateSubscriberCommand = serializeAws_restJson1CreateSubscriberCommand;
-const serializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand = async (input, context) => {
+exports.se_CreateSubscriberCommand = se_CreateSubscriberCommand;
+const se_CreateSubscriptionNotificationConfigurationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -205,8 +205,8 @@ const serializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand =
         body,
     });
 };
-exports.serializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand = serializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand;
-const serializeAws_restJson1DeleteAwsLogSourceCommand = async (input, context) => {
+exports.se_CreateSubscriptionNotificationConfigurationCommand = se_CreateSubscriptionNotificationConfigurationCommand;
+const se_DeleteAwsLogSourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -215,15 +215,15 @@ const serializeAws_restJson1DeleteAwsLogSourceCommand = async (input, context) =
     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 protocol_http_1.HttpRequest({
         protocol,
@@ -235,8 +235,8 @@ const serializeAws_restJson1DeleteAwsLogSourceCommand = async (input, context) =
         body,
     });
 };
-exports.serializeAws_restJson1DeleteAwsLogSourceCommand = serializeAws_restJson1DeleteAwsLogSourceCommand;
-const serializeAws_restJson1DeleteCustomLogSourceCommand = async (input, context) => {
+exports.se_DeleteAwsLogSourceCommand = se_DeleteAwsLogSourceCommand;
+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";
@@ -255,8 +255,8 @@ const serializeAws_restJson1DeleteCustomLogSourceCommand = async (input, context
         body,
     });
 };
-exports.serializeAws_restJson1DeleteCustomLogSourceCommand = serializeAws_restJson1DeleteCustomLogSourceCommand;
-const serializeAws_restJson1DeleteDatalakeCommand = async (input, context) => {
+exports.se_DeleteCustomLogSourceCommand = se_DeleteCustomLogSourceCommand;
+const se_DeleteDatalakeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -274,8 +274,8 @@ const serializeAws_restJson1DeleteDatalakeCommand = async (input, context) => {
         body,
     });
 };
-exports.serializeAws_restJson1DeleteDatalakeCommand = serializeAws_restJson1DeleteDatalakeCommand;
-const serializeAws_restJson1DeleteDatalakeAutoEnableCommand = async (input, context) => {
+exports.se_DeleteDatalakeCommand = se_DeleteDatalakeCommand;
+const se_DeleteDatalakeAutoEnableCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -284,7 +284,7 @@ const serializeAws_restJson1DeleteDatalakeAutoEnableCommand = async (input, cont
     let body;
     body = JSON.stringify({
         ...(input.removeFromConfigurationForNewAccounts != null && {
-            removeFromConfigurationForNewAccounts: serializeAws_restJson1AutoEnableNewRegionConfigurationList(input.removeFromConfigurationForNewAccounts, context),
+            removeFromConfigurationForNewAccounts: se_AutoEnableNewRegionConfigurationList(input.removeFromConfigurationForNewAccounts, context),
         }),
     });
     return new protocol_http_1.HttpRequest({
@@ -297,8 +297,8 @@ const serializeAws_restJson1DeleteDatalakeAutoEnableCommand = async (input, cont
         body,
     });
 };
-exports.serializeAws_restJson1DeleteDatalakeAutoEnableCommand = serializeAws_restJson1DeleteDatalakeAutoEnableCommand;
-const serializeAws_restJson1DeleteDatalakeDelegatedAdminCommand = async (input, context) => {
+exports.se_DeleteDatalakeAutoEnableCommand = se_DeleteDatalakeAutoEnableCommand;
+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}";
@@ -314,8 +314,8 @@ const serializeAws_restJson1DeleteDatalakeDelegatedAdminCommand = async (input,
         body,
     });
 };
-exports.serializeAws_restJson1DeleteDatalakeDelegatedAdminCommand = serializeAws_restJson1DeleteDatalakeDelegatedAdminCommand;
-const serializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand = async (input, context) => {
+exports.se_DeleteDatalakeDelegatedAdminCommand = se_DeleteDatalakeDelegatedAdminCommand;
+const se_DeleteDatalakeExceptionsSubscriptionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -333,8 +333,8 @@ const serializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand = async
         body,
     });
 };
-exports.serializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand = serializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand;
-const serializeAws_restJson1DeleteSubscriberCommand = async (input, context) => {
+exports.se_DeleteDatalakeExceptionsSubscriptionCommand = se_DeleteDatalakeExceptionsSubscriptionCommand;
+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";
@@ -353,8 +353,8 @@ const serializeAws_restJson1DeleteSubscriberCommand = async (input, context) =>
         body,
     });
 };
-exports.serializeAws_restJson1DeleteSubscriberCommand = serializeAws_restJson1DeleteSubscriberCommand;
-const serializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand = async (input, context) => {
+exports.se_DeleteSubscriberCommand = se_DeleteSubscriberCommand;
+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 || ""}` +
@@ -371,8 +371,8 @@ const serializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand =
         body,
     });
 };
-exports.serializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand = serializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand;
-const serializeAws_restJson1GetDatalakeCommand = async (input, context) => {
+exports.se_DeleteSubscriptionNotificationConfigurationCommand = se_DeleteSubscriptionNotificationConfigurationCommand;
+const se_GetDatalakeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -390,8 +390,8 @@ const serializeAws_restJson1GetDatalakeCommand = async (input, context) => {
         body,
     });
 };
-exports.serializeAws_restJson1GetDatalakeCommand = serializeAws_restJson1GetDatalakeCommand;
-const serializeAws_restJson1GetDatalakeAutoEnableCommand = async (input, context) => {
+exports.se_GetDatalakeCommand = se_GetDatalakeCommand;
+const se_GetDatalakeAutoEnableCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -409,8 +409,8 @@ const serializeAws_restJson1GetDatalakeAutoEnableCommand = async (input, context
         body,
     });
 };
-exports.serializeAws_restJson1GetDatalakeAutoEnableCommand = serializeAws_restJson1GetDatalakeAutoEnableCommand;
-const serializeAws_restJson1GetDatalakeExceptionsExpiryCommand = async (input, context) => {
+exports.se_GetDatalakeAutoEnableCommand = se_GetDatalakeAutoEnableCommand;
+const se_GetDatalakeExceptionsExpiryCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -428,8 +428,8 @@ const serializeAws_restJson1GetDatalakeExceptionsExpiryCommand = async (input, c
         body,
     });
 };
-exports.serializeAws_restJson1GetDatalakeExceptionsExpiryCommand = serializeAws_restJson1GetDatalakeExceptionsExpiryCommand;
-const serializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand = async (input, context) => {
+exports.se_GetDatalakeExceptionsExpiryCommand = se_GetDatalakeExceptionsExpiryCommand;
+const se_GetDatalakeExceptionsSubscriptionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -447,8 +447,8 @@ const serializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand = async (in
         body,
     });
 };
-exports.serializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand = serializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand;
-const serializeAws_restJson1GetDatalakeStatusCommand = async (input, context) => {
+exports.se_GetDatalakeExceptionsSubscriptionCommand = se_GetDatalakeExceptionsSubscriptionCommand;
+const se_GetDatalakeStatusCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -456,7 +456,7 @@ const serializeAws_restJson1GetDatalakeStatusCommand = async (input, context) =>
     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 }),
     });
@@ -470,8 +470,8 @@ const serializeAws_restJson1GetDatalakeStatusCommand = async (input, context) =>
         body,
     });
 };
-exports.serializeAws_restJson1GetDatalakeStatusCommand = serializeAws_restJson1GetDatalakeStatusCommand;
-const serializeAws_restJson1GetSubscriberCommand = async (input, context) => {
+exports.se_GetDatalakeStatusCommand = se_GetDatalakeStatusCommand;
+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}";
@@ -487,8 +487,8 @@ const serializeAws_restJson1GetSubscriberCommand = async (input, context) => {
         body,
     });
 };
-exports.serializeAws_restJson1GetSubscriberCommand = serializeAws_restJson1GetSubscriberCommand;
-const serializeAws_restJson1ListDatalakeExceptionsCommand = async (input, context) => {
+exports.se_GetSubscriberCommand = se_GetSubscriberCommand;
+const se_ListDatalakeExceptionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -498,7 +498,7 @@ const serializeAws_restJson1ListDatalakeExceptionsCommand = async (input, contex
     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 protocol_http_1.HttpRequest({
         protocol,
@@ -510,8 +510,8 @@ const serializeAws_restJson1ListDatalakeExceptionsCommand = async (input, contex
         body,
     });
 };
-exports.serializeAws_restJson1ListDatalakeExceptionsCommand = serializeAws_restJson1ListDatalakeExceptionsCommand;
-const serializeAws_restJson1ListLogSourcesCommand = async (input, context) => {
+exports.se_ListDatalakeExceptionsCommand = se_ListDatalakeExceptionsCommand;
+const se_ListLogSourcesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -519,15 +519,13 @@ 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 }),
@@ -542,8 +540,8 @@ const serializeAws_restJson1ListLogSourcesCommand = async (input, context) => {
         body,
     });
 };
-exports.serializeAws_restJson1ListLogSourcesCommand = serializeAws_restJson1ListLogSourcesCommand;
-const serializeAws_restJson1ListSubscribersCommand = async (input, context) => {
+exports.se_ListLogSourcesCommand = se_ListLogSourcesCommand;
+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";
@@ -563,8 +561,8 @@ const serializeAws_restJson1ListSubscribersCommand = async (input, context) => {
         body,
     });
 };
-exports.serializeAws_restJson1ListSubscribersCommand = serializeAws_restJson1ListSubscribersCommand;
-const serializeAws_restJson1UpdateDatalakeCommand = async (input, context) => {
+exports.se_ListSubscribersCommand = se_ListSubscribersCommand;
+const se_UpdateDatalakeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -573,7 +571,7 @@ 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 protocol_http_1.HttpRequest({
@@ -586,8 +584,8 @@ const serializeAws_restJson1UpdateDatalakeCommand = async (input, context) => {
         body,
     });
 };
-exports.serializeAws_restJson1UpdateDatalakeCommand = serializeAws_restJson1UpdateDatalakeCommand;
-const serializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand = async (input, context) => {
+exports.se_UpdateDatalakeCommand = se_UpdateDatalakeCommand;
+const se_UpdateDatalakeExceptionsExpiryCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -607,8 +605,8 @@ const serializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand = async (input
         body,
     });
 };
-exports.serializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand = serializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand;
-const serializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand = async (input, context) => {
+exports.se_UpdateDatalakeExceptionsExpiryCommand = se_UpdateDatalakeExceptionsExpiryCommand;
+const se_UpdateDatalakeExceptionsSubscriptionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -629,8 +627,8 @@ const serializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand = async
         body,
     });
 };
-exports.serializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand = serializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand;
-const serializeAws_restJson1UpdateSubscriberCommand = async (input, context) => {
+exports.se_UpdateDatalakeExceptionsSubscriptionCommand = se_UpdateDatalakeExceptionsSubscriptionCommand;
+const se_UpdateSubscriberCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -640,7 +638,7 @@ const serializeAws_restJson1UpdateSubscriberCommand = async (input, context) =>
     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 }),
     });
@@ -654,8 +652,8 @@ const serializeAws_restJson1UpdateSubscriberCommand = async (input, context) =>
         body,
     });
 };
-exports.serializeAws_restJson1UpdateSubscriberCommand = serializeAws_restJson1UpdateSubscriberCommand;
-const serializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand = async (input, context) => {
+exports.se_UpdateSubscriberCommand = se_UpdateSubscriberCommand;
+const se_UpdateSubscriptionNotificationConfigurationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -682,25 +680,25 @@ const serializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand =
         body,
     });
 };
-exports.serializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand = serializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand;
-const deserializeAws_restJson1CreateAwsLogSourceCommand = async (output, context) => {
+exports.se_UpdateSubscriptionNotificationConfigurationCommand = se_UpdateSubscriptionNotificationConfigurationCommand;
+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 = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.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;
 };
-exports.deserializeAws_restJson1CreateAwsLogSourceCommand = deserializeAws_restJson1CreateAwsLogSourceCommand;
-const deserializeAws_restJson1CreateAwsLogSourceCommandError = async (output, context) => {
+exports.de_CreateAwsLogSourceCommand = de_CreateAwsLogSourceCommand;
+const de_CreateAwsLogSourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -709,22 +707,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -735,9 +733,9 @@ const deserializeAws_restJson1CreateAwsLogSourceCommandError = async (output, co
             });
     }
 };
-const deserializeAws_restJson1CreateCustomLogSourceCommand = async (output, context) => {
+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),
@@ -760,8 +758,8 @@ const deserializeAws_restJson1CreateCustomLogSourceCommand = async (output, cont
     }
     return contents;
 };
-exports.deserializeAws_restJson1CreateCustomLogSourceCommand = deserializeAws_restJson1CreateCustomLogSourceCommand;
-const deserializeAws_restJson1CreateCustomLogSourceCommandError = async (output, context) => {
+exports.de_CreateCustomLogSourceCommand = de_CreateCustomLogSourceCommand;
+const de_CreateCustomLogSourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -770,25 +768,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -799,9 +797,9 @@ const deserializeAws_restJson1CreateCustomLogSourceCommandError = async (output,
             });
     }
 };
-const deserializeAws_restJson1CreateDatalakeCommand = async (output, context) => {
+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),
@@ -809,8 +807,8 @@ const deserializeAws_restJson1CreateDatalakeCommand = async (output, context) =>
     await collectBody(output.body, context);
     return contents;
 };
-exports.deserializeAws_restJson1CreateDatalakeCommand = deserializeAws_restJson1CreateDatalakeCommand;
-const deserializeAws_restJson1CreateDatalakeCommandError = async (output, context) => {
+exports.de_CreateDatalakeCommand = de_CreateDatalakeCommand;
+const de_CreateDatalakeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -819,25 +817,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -848,9 +846,9 @@ const deserializeAws_restJson1CreateDatalakeCommandError = async (output, contex
             });
     }
 };
-const deserializeAws_restJson1CreateDatalakeAutoEnableCommand = async (output, context) => {
+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),
@@ -858,8 +856,8 @@ const deserializeAws_restJson1CreateDatalakeAutoEnableCommand = async (output, c
     await collectBody(output.body, context);
     return contents;
 };
-exports.deserializeAws_restJson1CreateDatalakeAutoEnableCommand = deserializeAws_restJson1CreateDatalakeAutoEnableCommand;
-const deserializeAws_restJson1CreateDatalakeAutoEnableCommandError = async (output, context) => {
+exports.de_CreateDatalakeAutoEnableCommand = de_CreateDatalakeAutoEnableCommand;
+const de_CreateDatalakeAutoEnableCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -868,16 +866,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -888,9 +886,9 @@ const deserializeAws_restJson1CreateDatalakeAutoEnableCommandError = async (outp
             });
     }
 };
-const deserializeAws_restJson1CreateDatalakeDelegatedAdminCommand = async (output, context) => {
+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),
@@ -898,8 +896,8 @@ const deserializeAws_restJson1CreateDatalakeDelegatedAdminCommand = async (outpu
     await collectBody(output.body, context);
     return contents;
 };
-exports.deserializeAws_restJson1CreateDatalakeDelegatedAdminCommand = deserializeAws_restJson1CreateDatalakeDelegatedAdminCommand;
-const deserializeAws_restJson1CreateDatalakeDelegatedAdminCommandError = async (output, context) => {
+exports.de_CreateDatalakeDelegatedAdminCommand = de_CreateDatalakeDelegatedAdminCommand;
+const de_CreateDatalakeDelegatedAdminCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -908,16 +906,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -928,9 +926,9 @@ const deserializeAws_restJson1CreateDatalakeDelegatedAdminCommandError = async (
             });
     }
 };
-const deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand = async (output, context) => {
+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),
@@ -938,8 +936,8 @@ const deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand = asyn
     await collectBody(output.body, context);
     return contents;
 };
-exports.deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand = deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand;
-const deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
+exports.de_CreateDatalakeExceptionsSubscriptionCommand = de_CreateDatalakeExceptionsSubscriptionCommand;
+const de_CreateDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -948,16 +946,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -968,9 +966,9 @@ const deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommandError =
             });
     }
 };
-const deserializeAws_restJson1CreateSubscriberCommand = async (output, context) => {
+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),
@@ -996,8 +994,8 @@ const deserializeAws_restJson1CreateSubscriberCommand = async (output, context)
     }
     return contents;
 };
-exports.deserializeAws_restJson1CreateSubscriberCommand = deserializeAws_restJson1CreateSubscriberCommand;
-const deserializeAws_restJson1CreateSubscriberCommandError = async (output, context) => {
+exports.de_CreateSubscriberCommand = de_CreateSubscriberCommand;
+const de_CreateSubscriberCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1006,28 +1004,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1038,9 +1036,9 @@ const deserializeAws_restJson1CreateSubscriberCommandError = async (output, cont
             });
     }
 };
-const deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand = async (output, context) => {
+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),
@@ -1051,8 +1049,8 @@ const deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand
     }
     return contents;
 };
-exports.deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand = deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand;
-const deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommandError = async (output, context) => {
+exports.de_CreateSubscriptionNotificationConfigurationCommand = de_CreateSubscriptionNotificationConfigurationCommand;
+const de_CreateSubscriptionNotificationConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1061,25 +1059,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1090,24 +1088,24 @@ const deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand
             });
     }
 };
-const deserializeAws_restJson1DeleteAwsLogSourceCommand = async (output, context) => {
+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 = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.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;
 };
-exports.deserializeAws_restJson1DeleteAwsLogSourceCommand = deserializeAws_restJson1DeleteAwsLogSourceCommand;
-const deserializeAws_restJson1DeleteAwsLogSourceCommandError = async (output, context) => {
+exports.de_DeleteAwsLogSourceCommand = de_DeleteAwsLogSourceCommand;
+const de_DeleteAwsLogSourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1116,16 +1114,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1136,9 +1134,9 @@ const deserializeAws_restJson1DeleteAwsLogSourceCommandError = async (output, co
             });
     }
 };
-const deserializeAws_restJson1DeleteCustomLogSourceCommand = async (output, context) => {
+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),
@@ -1149,8 +1147,8 @@ const deserializeAws_restJson1DeleteCustomLogSourceCommand = async (output, cont
     }
     return contents;
 };
-exports.deserializeAws_restJson1DeleteCustomLogSourceCommand = deserializeAws_restJson1DeleteCustomLogSourceCommand;
-const deserializeAws_restJson1DeleteCustomLogSourceCommandError = async (output, context) => {
+exports.de_DeleteCustomLogSourceCommand = de_DeleteCustomLogSourceCommand;
+const de_DeleteCustomLogSourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1159,25 +1157,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1188,9 +1186,9 @@ const deserializeAws_restJson1DeleteCustomLogSourceCommandError = async (output,
             });
     }
 };
-const deserializeAws_restJson1DeleteDatalakeCommand = async (output, context) => {
+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),
@@ -1198,8 +1196,8 @@ const deserializeAws_restJson1DeleteDatalakeCommand = async (output, context) =>
     await collectBody(output.body, context);
     return contents;
 };
-exports.deserializeAws_restJson1DeleteDatalakeCommand = deserializeAws_restJson1DeleteDatalakeCommand;
-const deserializeAws_restJson1DeleteDatalakeCommandError = async (output, context) => {
+exports.de_DeleteDatalakeCommand = de_DeleteDatalakeCommand;
+const de_DeleteDatalakeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1208,25 +1206,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1237,9 +1235,9 @@ const deserializeAws_restJson1DeleteDatalakeCommandError = async (output, contex
             });
     }
 };
-const deserializeAws_restJson1DeleteDatalakeAutoEnableCommand = async (output, context) => {
+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),
@@ -1247,8 +1245,8 @@ const deserializeAws_restJson1DeleteDatalakeAutoEnableCommand = async (output, c
     await collectBody(output.body, context);
     return contents;
 };
-exports.deserializeAws_restJson1DeleteDatalakeAutoEnableCommand = deserializeAws_restJson1DeleteDatalakeAutoEnableCommand;
-const deserializeAws_restJson1DeleteDatalakeAutoEnableCommandError = async (output, context) => {
+exports.de_DeleteDatalakeAutoEnableCommand = de_DeleteDatalakeAutoEnableCommand;
+const de_DeleteDatalakeAutoEnableCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1257,16 +1255,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1277,9 +1275,9 @@ const deserializeAws_restJson1DeleteDatalakeAutoEnableCommandError = async (outp
             });
     }
 };
-const deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommand = async (output, context) => {
+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),
@@ -1287,8 +1285,8 @@ const deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommand = async (outpu
     await collectBody(output.body, context);
     return contents;
 };
-exports.deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommand = deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommand;
-const deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommandError = async (output, context) => {
+exports.de_DeleteDatalakeDelegatedAdminCommand = de_DeleteDatalakeDelegatedAdminCommand;
+const de_DeleteDatalakeDelegatedAdminCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1297,16 +1295,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1317,9 +1315,9 @@ const deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommandError = async (
             });
     }
 };
-const deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand = async (output, context) => {
+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),
@@ -1330,8 +1328,8 @@ const deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand = asyn
     }
     return contents;
 };
-exports.deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand = deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand;
-const deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
+exports.de_DeleteDatalakeExceptionsSubscriptionCommand = de_DeleteDatalakeExceptionsSubscriptionCommand;
+const de_DeleteDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1340,16 +1338,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1360,9 +1358,9 @@ const deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommandError =
             });
     }
 };
-const deserializeAws_restJson1DeleteSubscriberCommand = async (output, context) => {
+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),
@@ -1370,8 +1368,8 @@ const deserializeAws_restJson1DeleteSubscriberCommand = async (output, context)
     await collectBody(output.body, context);
     return contents;
 };
-exports.deserializeAws_restJson1DeleteSubscriberCommand = deserializeAws_restJson1DeleteSubscriberCommand;
-const deserializeAws_restJson1DeleteSubscriberCommandError = async (output, context) => {
+exports.de_DeleteSubscriberCommand = de_DeleteSubscriberCommand;
+const de_DeleteSubscriberCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1380,28 +1378,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1412,9 +1410,9 @@ const deserializeAws_restJson1DeleteSubscriberCommandError = async (output, cont
             });
     }
 };
-const deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand = async (output, context) => {
+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),
@@ -1422,8 +1420,8 @@ const deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand
     await collectBody(output.body, context);
     return contents;
 };
-exports.deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand = deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand;
-const deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommandError = async (output, context) => {
+exports.de_DeleteSubscriptionNotificationConfigurationCommand = de_DeleteSubscriptionNotificationConfigurationCommand;
+const de_DeleteSubscriptionNotificationConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1432,25 +1430,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1461,21 +1459,21 @@ const deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand
             });
     }
 };
-const deserializeAws_restJson1GetDatalakeCommand = async (output, context) => {
+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 = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.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;
 };
-exports.deserializeAws_restJson1GetDatalakeCommand = deserializeAws_restJson1GetDatalakeCommand;
-const deserializeAws_restJson1GetDatalakeCommandError = async (output, context) => {
+exports.de_GetDatalakeCommand = de_GetDatalakeCommand;
+const de_GetDatalakeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1484,19 +1482,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1507,21 +1505,21 @@ const deserializeAws_restJson1GetDatalakeCommandError = async (output, context)
             });
     }
 };
-const deserializeAws_restJson1GetDatalakeAutoEnableCommand = async (output, context) => {
+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 = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.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;
 };
-exports.deserializeAws_restJson1GetDatalakeAutoEnableCommand = deserializeAws_restJson1GetDatalakeAutoEnableCommand;
-const deserializeAws_restJson1GetDatalakeAutoEnableCommandError = async (output, context) => {
+exports.de_GetDatalakeAutoEnableCommand = de_GetDatalakeAutoEnableCommand;
+const de_GetDatalakeAutoEnableCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1530,16 +1528,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1550,9 +1548,9 @@ const deserializeAws_restJson1GetDatalakeAutoEnableCommandError = async (output,
             });
     }
 };
-const deserializeAws_restJson1GetDatalakeExceptionsExpiryCommand = async (output, context) => {
+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),
@@ -1563,8 +1561,8 @@ const deserializeAws_restJson1GetDatalakeExceptionsExpiryCommand = async (output
     }
     return contents;
 };
-exports.deserializeAws_restJson1GetDatalakeExceptionsExpiryCommand = deserializeAws_restJson1GetDatalakeExceptionsExpiryCommand;
-const deserializeAws_restJson1GetDatalakeExceptionsExpiryCommandError = async (output, context) => {
+exports.de_GetDatalakeExceptionsExpiryCommand = de_GetDatalakeExceptionsExpiryCommand;
+const de_GetDatalakeExceptionsExpiryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1573,16 +1571,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1593,21 +1591,21 @@ const deserializeAws_restJson1GetDatalakeExceptionsExpiryCommandError = async (o
             });
     }
 };
-const deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand = async (output, context) => {
+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 = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.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;
 };
-exports.deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand = deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand;
-const deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
+exports.de_GetDatalakeExceptionsSubscriptionCommand = de_GetDatalakeExceptionsSubscriptionCommand;
+const de_GetDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1616,16 +1614,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1636,24 +1634,24 @@ const deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommandError = as
             });
     }
 };
-const deserializeAws_restJson1GetDatalakeStatusCommand = async (output, context) => {
+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 = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.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 = (0, smithy_client_1.expectString)(data.nextToken);
     }
     return contents;
 };
-exports.deserializeAws_restJson1GetDatalakeStatusCommand = deserializeAws_restJson1GetDatalakeStatusCommand;
-const deserializeAws_restJson1GetDatalakeStatusCommandError = async (output, context) => {
+exports.de_GetDatalakeStatusCommand = de_GetDatalakeStatusCommand;
+const de_GetDatalakeStatusCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1662,16 +1660,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1682,21 +1680,21 @@ const deserializeAws_restJson1GetDatalakeStatusCommandError = async (output, con
             });
     }
 };
-const deserializeAws_restJson1GetSubscriberCommand = async (output, context) => {
+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 = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.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;
 };
-exports.deserializeAws_restJson1GetSubscriberCommand = deserializeAws_restJson1GetSubscriberCommand;
-const deserializeAws_restJson1GetSubscriberCommandError = async (output, context) => {
+exports.de_GetSubscriberCommand = de_GetSubscriberCommand;
+const de_GetSubscriberCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1705,19 +1703,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1728,9 +1726,9 @@ const deserializeAws_restJson1GetSubscriberCommandError = async (output, context
             });
     }
 };
-const deserializeAws_restJson1ListDatalakeExceptionsCommand = async (output, context) => {
+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),
@@ -1740,12 +1738,12 @@ const deserializeAws_restJson1ListDatalakeExceptionsCommand = async (output, con
         contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
     }
     if (data.nonRetryableFailures != null) {
-        contents.nonRetryableFailures = deserializeAws_restJson1FailuresResponseList(data.nonRetryableFailures, context);
+        contents.nonRetryableFailures = de_FailuresResponseList(data.nonRetryableFailures, context);
     }
     return contents;
 };
-exports.deserializeAws_restJson1ListDatalakeExceptionsCommand = deserializeAws_restJson1ListDatalakeExceptionsCommand;
-const deserializeAws_restJson1ListDatalakeExceptionsCommandError = async (output, context) => {
+exports.de_ListDatalakeExceptionsCommand = de_ListDatalakeExceptionsCommand;
+const de_ListDatalakeExceptionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1754,16 +1752,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1774,9 +1772,9 @@ const deserializeAws_restJson1ListDatalakeExceptionsCommandError = async (output
             });
     }
 };
-const deserializeAws_restJson1ListLogSourcesCommand = async (output, context) => {
+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),
@@ -1786,12 +1784,12 @@ const deserializeAws_restJson1ListLogSourcesCommand = async (output, context) =>
         contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
     }
     if (data.regionSourceTypesAccountsList != null) {
-        contents.regionSourceTypesAccountsList = deserializeAws_restJson1RegionSourceTypesAccountsList(data.regionSourceTypesAccountsList, context);
+        contents.regionSourceTypesAccountsList = de_RegionSourceTypesAccountsList(data.regionSourceTypesAccountsList, context);
     }
     return contents;
 };
-exports.deserializeAws_restJson1ListLogSourcesCommand = deserializeAws_restJson1ListLogSourcesCommand;
-const deserializeAws_restJson1ListLogSourcesCommandError = async (output, context) => {
+exports.de_ListLogSourcesCommand = de_ListLogSourcesCommand;
+const de_ListLogSourcesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1800,19 +1798,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1823,9 +1821,9 @@ const deserializeAws_restJson1ListLogSourcesCommandError = async (output, contex
             });
     }
 };
-const deserializeAws_restJson1ListSubscribersCommand = async (output, context) => {
+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),
@@ -1835,12 +1833,12 @@ const deserializeAws_restJson1ListSubscribersCommand = async (output, context) =
         contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
     }
     if (data.subscribers != null) {
-        contents.subscribers = deserializeAws_restJson1SubscriberList(data.subscribers, context);
+        contents.subscribers = de_SubscriberList(data.subscribers, context);
     }
     return contents;
 };
-exports.deserializeAws_restJson1ListSubscribersCommand = deserializeAws_restJson1ListSubscribersCommand;
-const deserializeAws_restJson1ListSubscribersCommandError = async (output, context) => {
+exports.de_ListSubscribersCommand = de_ListSubscribersCommand;
+const de_ListSubscribersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1849,22 +1847,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1875,9 +1873,9 @@ const deserializeAws_restJson1ListSubscribersCommandError = async (output, conte
             });
     }
 };
-const deserializeAws_restJson1UpdateDatalakeCommand = async (output, context) => {
+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),
@@ -1885,8 +1883,8 @@ const deserializeAws_restJson1UpdateDatalakeCommand = async (output, context) =>
     await collectBody(output.body, context);
     return contents;
 };
-exports.deserializeAws_restJson1UpdateDatalakeCommand = deserializeAws_restJson1UpdateDatalakeCommand;
-const deserializeAws_restJson1UpdateDatalakeCommandError = async (output, context) => {
+exports.de_UpdateDatalakeCommand = de_UpdateDatalakeCommand;
+const de_UpdateDatalakeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1895,19 +1893,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1918,9 +1916,9 @@ const deserializeAws_restJson1UpdateDatalakeCommandError = async (output, contex
             });
     }
 };
-const deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand = async (output, context) => {
+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),
@@ -1928,8 +1926,8 @@ const deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand = async (out
     await collectBody(output.body, context);
     return contents;
 };
-exports.deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand = deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand;
-const deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommandError = async (output, context) => {
+exports.de_UpdateDatalakeExceptionsExpiryCommand = de_UpdateDatalakeExceptionsExpiryCommand;
+const de_UpdateDatalakeExceptionsExpiryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1938,16 +1936,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1958,9 +1956,9 @@ const deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommandError = async
             });
     }
 };
-const deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand = async (output, context) => {
+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),
@@ -1968,8 +1966,8 @@ const deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand = asyn
     await collectBody(output.body, context);
     return contents;
 };
-exports.deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand = deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand;
-const deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
+exports.de_UpdateDatalakeExceptionsSubscriptionCommand = de_UpdateDatalakeExceptionsSubscriptionCommand;
+const de_UpdateDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1978,16 +1976,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -1998,21 +1996,21 @@ const deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommandError =
             });
     }
 };
-const deserializeAws_restJson1UpdateSubscriberCommand = async (output, context) => {
+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 = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.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;
 };
-exports.deserializeAws_restJson1UpdateSubscriberCommand = deserializeAws_restJson1UpdateSubscriberCommand;
-const deserializeAws_restJson1UpdateSubscriberCommandError = async (output, context) => {
+exports.de_UpdateSubscriberCommand = de_UpdateSubscriberCommand;
+const de_UpdateSubscriberCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2021,25 +2019,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -2050,9 +2048,9 @@ const deserializeAws_restJson1UpdateSubscriberCommandError = async (output, cont
             });
     }
 };
-const deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand = async (output, context) => {
+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),
@@ -2063,8 +2061,8 @@ const deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand
     }
     return contents;
 };
-exports.deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand = deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand;
-const deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommandError = async (output, context) => {
+exports.de_UpdateSubscriptionNotificationConfigurationCommand = de_UpdateSubscriptionNotificationConfigurationCommand;
+const de_UpdateSubscriptionNotificationConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2073,25 +2071,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;
             (0, smithy_client_1.throwDefaultError)({
@@ -2103,7 +2101,7 @@ const deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand
     }
 };
 const map = smithy_client_1.map;
-const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
+const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.errorCode != null) {
@@ -2118,7 +2116,7 @@ const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutpu
     });
     return (0, smithy_client_1.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) {
@@ -2130,7 +2128,7 @@ const deserializeAws_restJson1AccountNotFoundExceptionResponse = async (parsedOu
     });
     return (0, smithy_client_1.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) {
@@ -2142,7 +2140,7 @@ const deserializeAws_restJson1BucketNotFoundExceptionResponse = async (parsedOut
     });
     return (0, smithy_client_1.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) {
@@ -2154,7 +2152,7 @@ const deserializeAws_restJson1ConcurrentModificationExceptionResponse = async (p
     });
     return (0, smithy_client_1.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) {
@@ -2172,7 +2170,7 @@ const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, c
     });
     return (0, smithy_client_1.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) {
@@ -2184,7 +2182,7 @@ const deserializeAws_restJson1ConflictSourceNamesExceptionResponse = async (pars
     });
     return (0, smithy_client_1.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) {
@@ -2196,7 +2194,7 @@ const deserializeAws_restJson1ConflictSubscriptionExceptionResponse = async (par
     });
     return (0, smithy_client_1.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) {
@@ -2208,7 +2206,7 @@ const deserializeAws_restJson1EventBridgeExceptionResponse = async (parsedOutput
     });
     return (0, smithy_client_1.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"],
@@ -2225,7 +2223,7 @@ const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOut
     });
     return (0, smithy_client_1.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) {
@@ -2237,7 +2235,7 @@ const deserializeAws_restJson1InvalidInputExceptionResponse = async (parsedOutpu
     });
     return (0, smithy_client_1.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) {
@@ -2255,7 +2253,7 @@ const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedO
     });
     return (0, smithy_client_1.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) {
@@ -2267,7 +2265,7 @@ const deserializeAws_restJson1S3ExceptionResponse = async (parsedOutput, context
     });
     return (0, smithy_client_1.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) {
@@ -2291,7 +2289,7 @@ const deserializeAws_restJson1ServiceQuotaExceededExceptionResponse = async (par
     });
     return (0, smithy_client_1.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"],
@@ -2314,11 +2312,11 @@ const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput,
     });
     return (0, smithy_client_1.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 = (0, smithy_client_1.expectString)(data.message);
@@ -2332,113 +2330,113 @@ const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput,
     });
     return (0, smithy_client_1.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 models_0_1.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;
@@ -2447,23 +2445,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) => {
@@ -2474,7 +2472,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) => {
@@ -2485,52 +2483,52 @@ const deserializeAws_restJson1AccountList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1AccountSources = (output, context) => {
+const de_AccountSources = (output, context) => {
     return {
         account: (0, smithy_client_1.expectString)(output.account),
         eventClass: (0, smithy_client_1.expectString)(output.eventClass),
-        logsStatus: output.logsStatus != null ? deserializeAws_restJson1LogsStatusList(output.logsStatus, context) : undefined,
+        logsStatus: output.logsStatus != null ? de_LogsStatusList(output.logsStatus, context) : undefined,
         sourceType: (0, smithy_client_1.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: (0, smithy_client_1.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) => {
@@ -2541,96 +2539,94 @@ const deserializeAws_restJson1AwsSourceTypeList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1Failures = (output, context) => {
+const de_Failures = (output, context) => {
     return {
         exceptionMessage: (0, smithy_client_1.expectString)(output.exceptionMessage),
         remediation: (0, smithy_client_1.expectString)(output.remediation),
         timestamp: output.timestamp != null ? (0, smithy_client_1.expectNonNull)((0, smithy_client_1.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: (0, smithy_client_1.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: (0, smithy_client_1.expectString)(output.encryptionKey),
         replicationDestinationRegions: output.replicationDestinationRegions != null
-            ? deserializeAws_restJson1RegionSet(output.replicationDestinationRegions, context)
+            ? de_RegionSet(output.replicationDestinationRegions, context)
             : undefined,
         replicationRoleArn: (0, smithy_client_1.expectString)(output.replicationRoleArn),
-        retentionSettings: output.retentionSettings != null
-            ? deserializeAws_restJson1RetentionSettingList(output.retentionSettings, context)
-            : undefined,
+        retentionSettings: output.retentionSettings != null ? de_RetentionSettingList(output.retentionSettings, context) : undefined,
         s3BucketArn: (0, smithy_client_1.expectString)(output.s3BucketArn),
         status: (0, smithy_client_1.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: (0, smithy_client_1.expectString)(output.code),
         reason: (0, smithy_client_1.expectString)(output.reason),
     };
 };
-const deserializeAws_restJson1LogsStatus = (output, context) => {
+const de_LogsStatus = (output, context) => {
     return {
         healthStatus: (0, smithy_client_1.expectString)(output.healthStatus),
         pathToLogs: (0, smithy_client_1.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: (0, smithy_client_1.expectString)(output.endpoint),
         protocol: (0, smithy_client_1.expectString)(output.protocol),
     };
 };
-const deserializeAws_restJson1RegionSet = (output, context) => {
+const de_RegionSet = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2641,35 +2637,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: (0, smithy_client_1.expectInt32)(output.retentionPeriod),
         storageClass: (0, smithy_client_1.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 ((0, smithy_client_1.expectString)(output.awsSourceType) !== undefined) {
         return { awsSourceType: (0, smithy_client_1.expectString)(output.awsSourceType) };
     }
@@ -2678,31 +2674,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((0, smithy_client_1.expectUnion)(entry), context);
+        return de_SourceType((0, smithy_client_1.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: (0, smithy_client_1.expectString)(output.accountId),
         createdAt: output.createdAt != null ? (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output.createdAt)) : undefined,
         externalId: (0, smithy_client_1.expectString)(output.externalId),
@@ -2711,7 +2707,7 @@ const deserializeAws_restJson1SubscriberResource = (output, context) => {
         roleArn: (0, smithy_client_1.expectString)(output.roleArn),
         s3BucketArn: (0, smithy_client_1.expectString)(output.s3BucketArn),
         snsArn: (0, smithy_client_1.expectString)(output.snsArn),
-        sourceTypes: output.sourceTypes != null ? deserializeAws_restJson1SourceTypeList(output.sourceTypes, context) : undefined,
+        sourceTypes: output.sourceTypes != null ? de_SourceTypeList(output.sourceTypes, context) : undefined,
         subscriberDescription: (0, smithy_client_1.expectString)(output.subscriberDescription),
         subscriberName: (0, smithy_client_1.expectString)(output.subscriberName),
         subscriptionEndpoint: (0, smithy_client_1.expectString)(output.subscriptionEndpoint),
@@ -2721,7 +2717,7 @@ const deserializeAws_restJson1SubscriberResource = (output, context) => {
         updatedAt: output.updatedAt != null ? (0, smithy_client_1.expectNonNull)((0, smithy_client_1.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;
@@ -2730,42 +2726,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: (0, smithy_client_1.expectString)(output.lastUpdateRequestId),
         lastUpdateStatus: (0, smithy_client_1.expectString)(output.lastUpdateStatus),
     };
 };
-const deserializeAws_restJson1ValidationExceptionField = (output, context) => {
+const de_ValidationExceptionField = (output, context) => {
     return {
         message: (0, smithy_client_1.expectString)(output.message),
         name: (0, smithy_client_1.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) => {