@aws-sdk/client-securitylake 3.220.0

package/dist-cjs/protocols/Aws_restJson1.js

@@ -0,0 +1,2809 @@
+"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;
+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 { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/logsources/aws";
+    let body;
+    body = JSON.stringify({
+        ...(input.enableAllDimensions != null && {
+            enableAllDimensions: serializeAws_restJson1AllDimensionsMap(input.enableAllDimensions, context),
+        }),
+        ...(input.enableSingleDimension != null && {
+            enableSingleDimension: serializeAws_restJson1InputSet(input.enableSingleDimension, context),
+        }),
+        ...(input.enableTwoDimensions != null && {
+            enableTwoDimensions: serializeAws_restJson1TwoDimensionsMap(input.enableTwoDimensions, context),
+        }),
+        ...(input.inputOrder != null && { inputOrder: serializeAws_restJson1DimensionSet(input.inputOrder, context) }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CreateAwsLogSourceCommand = serializeAws_restJson1CreateAwsLogSourceCommand;
+const serializeAws_restJson1CreateCustomLogSourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/logsources/custom";
+    let body;
+    body = JSON.stringify({
+        ...(input.customSourceName != null && { customSourceName: input.customSourceName }),
+        ...(input.eventClass != null && { eventClass: input.eventClass }),
+        ...(input.glueInvocationRoleArn != null && { glueInvocationRoleArn: input.glueInvocationRoleArn }),
+        ...(input.logProviderAccountId != null && { logProviderAccountId: input.logProviderAccountId }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CreateCustomLogSourceCommand = serializeAws_restJson1CreateCustomLogSourceCommand;
+const serializeAws_restJson1CreateDatalakeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake";
+    let body;
+    body = JSON.stringify({
+        ...(input.configurations != null && {
+            configurations: serializeAws_restJson1LakeConfigurationRequestMap(input.configurations, context),
+        }),
+        ...(input.enableAll != null && { enableAll: input.enableAll }),
+        ...(input.metaStoreManagerRoleArn != null && { metaStoreManagerRoleArn: input.metaStoreManagerRoleArn }),
+        ...(input.regions != null && { regions: serializeAws_restJson1RegionSet(input.regions, context) }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CreateDatalakeCommand = serializeAws_restJson1CreateDatalakeCommand;
+const serializeAws_restJson1CreateDatalakeAutoEnableCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/autoenable";
+    let body;
+    body = JSON.stringify({
+        ...(input.configurationForNewAccounts != null && {
+            configurationForNewAccounts: serializeAws_restJson1AutoEnableNewRegionConfigurationList(input.configurationForNewAccounts, context),
+        }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CreateDatalakeAutoEnableCommand = serializeAws_restJson1CreateDatalakeAutoEnableCommand;
+const serializeAws_restJson1CreateDatalakeDelegatedAdminCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/delegate";
+    let body;
+    body = JSON.stringify({
+        ...(input.account != null && { account: input.account }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CreateDatalakeDelegatedAdminCommand = serializeAws_restJson1CreateDatalakeDelegatedAdminCommand;
+const serializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/exceptions/subscription";
+    let body;
+    body = JSON.stringify({
+        ...(input.notificationEndpoint != null && { notificationEndpoint: input.notificationEndpoint }),
+        ...(input.subscriptionProtocol != null && { subscriptionProtocol: input.subscriptionProtocol }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand = serializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand;
+const serializeAws_restJson1CreateSubscriberCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    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.accountId != null && { accountId: input.accountId }),
+        ...(input.externalId != null && { externalId: input.externalId }),
+        ...(input.sourceTypes != null && { sourceTypes: serializeAws_restJson1SourceTypeList(input.sourceTypes, context) }),
+        ...(input.subscriberDescription != null && { subscriberDescription: input.subscriberDescription }),
+        ...(input.subscriberName != null && { subscriberName: input.subscriberName }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CreateSubscriberCommand = serializeAws_restJson1CreateSubscriberCommand;
+const serializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/subscription-notifications/{subscriptionId}";
+    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "subscriptionId", () => input.subscriptionId, "{subscriptionId}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.createSqs != null && { createSqs: input.createSqs }),
+        ...(input.httpsApiKeyName != null && { httpsApiKeyName: input.httpsApiKeyName }),
+        ...(input.httpsApiKeyValue != null && { httpsApiKeyValue: input.httpsApiKeyValue }),
+        ...(input.httpsMethod != null && { httpsMethod: input.httpsMethod }),
+        ...(input.roleArn != null && { roleArn: input.roleArn }),
+        ...(input.subscriptionEndpoint != null && { subscriptionEndpoint: input.subscriptionEndpoint }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand = serializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand;
+const serializeAws_restJson1DeleteAwsLogSourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/logsources/aws/delete";
+    let body;
+    body = JSON.stringify({
+        ...(input.disableAllDimensions != null && {
+            disableAllDimensions: serializeAws_restJson1AllDimensionsMap(input.disableAllDimensions, context),
+        }),
+        ...(input.disableSingleDimension != null && {
+            disableSingleDimension: serializeAws_restJson1InputSet(input.disableSingleDimension, context),
+        }),
+        ...(input.disableTwoDimensions != null && {
+            disableTwoDimensions: serializeAws_restJson1TwoDimensionsMap(input.disableTwoDimensions, context),
+        }),
+        ...(input.inputOrder != null && { inputOrder: serializeAws_restJson1DimensionSet(input.inputOrder, context) }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1DeleteAwsLogSourceCommand = serializeAws_restJson1DeleteAwsLogSourceCommand;
+const serializeAws_restJson1DeleteCustomLogSourceCommand = 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";
+    const query = map({
+        customSourceName: [, (0, smithy_client_1.expectNonNull)(input.customSourceName, `customSourceName`)],
+    });
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1DeleteCustomLogSourceCommand = serializeAws_restJson1DeleteCustomLogSourceCommand;
+const serializeAws_restJson1DeleteDatalakeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake";
+    let body;
+    body = "";
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1DeleteDatalakeCommand = serializeAws_restJson1DeleteDatalakeCommand;
+const serializeAws_restJson1DeleteDatalakeAutoEnableCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/autoenable/delete";
+    let body;
+    body = JSON.stringify({
+        ...(input.removeFromConfigurationForNewAccounts != null && {
+            removeFromConfigurationForNewAccounts: serializeAws_restJson1AutoEnableNewRegionConfigurationList(input.removeFromConfigurationForNewAccounts, context),
+        }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1DeleteDatalakeAutoEnableCommand = serializeAws_restJson1DeleteDatalakeAutoEnableCommand;
+const serializeAws_restJson1DeleteDatalakeDelegatedAdminCommand = 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}";
+    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "account", () => input.account, "{account}", false);
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1DeleteDatalakeDelegatedAdminCommand = serializeAws_restJson1DeleteDatalakeDelegatedAdminCommand;
+const serializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/exceptions/subscription";
+    let body;
+    body = "";
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand = serializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand;
+const serializeAws_restJson1DeleteSubscriberCommand = 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";
+    const query = map({
+        id: [, (0, smithy_client_1.expectNonNull)(input.id, `id`)],
+    });
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1DeleteSubscriberCommand = serializeAws_restJson1DeleteSubscriberCommand;
+const serializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/subscription-notifications/{subscriptionId}";
+    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "subscriptionId", () => input.subscriptionId, "{subscriptionId}", false);
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand = serializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand;
+const serializeAws_restJson1GetDatalakeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake";
+    let body;
+    body = "";
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetDatalakeCommand = serializeAws_restJson1GetDatalakeCommand;
+const serializeAws_restJson1GetDatalakeAutoEnableCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/autoenable";
+    let body;
+    body = "";
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetDatalakeAutoEnableCommand = serializeAws_restJson1GetDatalakeAutoEnableCommand;
+const serializeAws_restJson1GetDatalakeExceptionsExpiryCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/exceptions/expiry";
+    let body;
+    body = "";
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetDatalakeExceptionsExpiryCommand = serializeAws_restJson1GetDatalakeExceptionsExpiryCommand;
+const serializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/exceptions/subscription";
+    let body;
+    body = "";
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand = serializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand;
+const serializeAws_restJson1GetDatalakeStatusCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    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.maxAccountResults != null && { maxAccountResults: input.maxAccountResults }),
+        ...(input.nextToken != null && { nextToken: input.nextToken }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetDatalakeStatusCommand = serializeAws_restJson1GetDatalakeStatusCommand;
+const serializeAws_restJson1GetSubscriberCommand = 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}";
+    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "id", () => input.id, "{id}", false);
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetSubscriberCommand = serializeAws_restJson1GetSubscriberCommand;
+const serializeAws_restJson1ListDatalakeExceptionsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/exceptions";
+    let body;
+    body = JSON.stringify({
+        ...(input.maxFailures != null && { maxFailures: input.maxFailures }),
+        ...(input.nextToken != null && { nextToken: input.nextToken }),
+        ...(input.regionSet != null && { regionSet: serializeAws_restJson1RegionSet(input.regionSet, context) }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListDatalakeExceptionsCommand = serializeAws_restJson1ListDatalakeExceptionsCommand;
+const serializeAws_restJson1ListLogSourcesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    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.listAllDimensions != null && {
+            listAllDimensions: serializeAws_restJson1AllDimensionsMap(input.listAllDimensions, context),
+        }),
+        ...(input.listSingleDimension != null && {
+            listSingleDimension: serializeAws_restJson1InputSet(input.listSingleDimension, context),
+        }),
+        ...(input.listTwoDimensions != null && {
+            listTwoDimensions: serializeAws_restJson1TwoDimensionsMap(input.listTwoDimensions, context),
+        }),
+        ...(input.maxResults != null && { maxResults: input.maxResults }),
+        ...(input.nextToken != null && { nextToken: input.nextToken }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListLogSourcesCommand = serializeAws_restJson1ListLogSourcesCommand;
+const serializeAws_restJson1ListSubscribersCommand = 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";
+    const query = map({
+        nextToken: [, input.nextToken],
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+    });
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListSubscribersCommand = serializeAws_restJson1ListSubscribersCommand;
+const serializeAws_restJson1UpdateDatalakeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake";
+    let body;
+    body = JSON.stringify({
+        ...(input.configurations != null && {
+            configurations: serializeAws_restJson1LakeConfigurationRequestMap(input.configurations, context),
+        }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1UpdateDatalakeCommand = serializeAws_restJson1UpdateDatalakeCommand;
+const serializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/exceptions/expiry";
+    let body;
+    body = JSON.stringify({
+        ...(input.exceptionMessageExpiry != null && { exceptionMessageExpiry: input.exceptionMessageExpiry }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand = serializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand;
+const serializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/exceptions/subscription";
+    let body;
+    body = JSON.stringify({
+        ...(input.notificationEndpoint != null && { notificationEndpoint: input.notificationEndpoint }),
+        ...(input.subscriptionProtocol != null && { subscriptionProtocol: input.subscriptionProtocol }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand = serializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand;
+const serializeAws_restJson1UpdateSubscriberCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/subscribers/{id}";
+    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "id", () => input.id, "{id}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.externalId != null && { externalId: input.externalId }),
+        ...(input.sourceTypes != null && { sourceTypes: serializeAws_restJson1SourceTypeList(input.sourceTypes, context) }),
+        ...(input.subscriberDescription != null && { subscriberDescription: input.subscriberDescription }),
+        ...(input.subscriberName != null && { subscriberName: input.subscriberName }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1UpdateSubscriberCommand = serializeAws_restJson1UpdateSubscriberCommand;
+const serializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/subscription-notifications/{subscriptionId}";
+    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "subscriptionId", () => input.subscriptionId, "{subscriptionId}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.createSqs != null && { createSqs: input.createSqs }),
+        ...(input.httpsApiKeyName != null && { httpsApiKeyName: input.httpsApiKeyName }),
+        ...(input.httpsApiKeyValue != null && { httpsApiKeyValue: input.httpsApiKeyValue }),
+        ...(input.httpsMethod != null && { httpsMethod: input.httpsMethod }),
+        ...(input.roleArn != null && { roleArn: input.roleArn }),
+        ...(input.subscriptionEndpoint != null && { subscriptionEndpoint: input.subscriptionEndpoint }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand = serializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand;
+const deserializeAws_restJson1CreateAwsLogSourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateAwsLogSourceCommandError(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);
+    }
+    if (data.processing != null) {
+        contents.processing = deserializeAws_restJson1AccountList(data.processing, context);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1CreateAwsLogSourceCommand = deserializeAws_restJson1CreateAwsLogSourceCommand;
+const deserializeAws_restJson1CreateAwsLogSourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "S3Exception":
+        case "com.amazonaws.securitylake#S3Exception":
+            throw await deserializeAws_restJson1S3ExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1CreateCustomLogSourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateCustomLogSourceCommandError(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.customDataLocation != null) {
+        contents.customDataLocation = (0, smithy_client_1.expectString)(data.customDataLocation);
+    }
+    if (data.glueCrawlerName != null) {
+        contents.glueCrawlerName = (0, smithy_client_1.expectString)(data.glueCrawlerName);
+    }
+    if (data.glueDatabaseName != null) {
+        contents.glueDatabaseName = (0, smithy_client_1.expectString)(data.glueDatabaseName);
+    }
+    if (data.glueTableName != null) {
+        contents.glueTableName = (0, smithy_client_1.expectString)(data.glueTableName);
+    }
+    if (data.logProviderAccessRoleArn != null) {
+        contents.logProviderAccessRoleArn = (0, smithy_client_1.expectString)(data.logProviderAccessRoleArn);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1CreateCustomLogSourceCommand = deserializeAws_restJson1CreateCustomLogSourceCommand;
+const deserializeAws_restJson1CreateCustomLogSourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "BucketNotFoundException":
+        case "com.amazonaws.securitylake#BucketNotFoundException":
+            throw await deserializeAws_restJson1BucketNotFoundExceptionResponse(parsedOutput, context);
+        case "ConflictSourceNamesException":
+        case "com.amazonaws.securitylake#ConflictSourceNamesException":
+            throw await deserializeAws_restJson1ConflictSourceNamesExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1CreateDatalakeCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateDatalakeCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+exports.deserializeAws_restJson1CreateDatalakeCommand = deserializeAws_restJson1CreateDatalakeCommand;
+const deserializeAws_restJson1CreateDatalakeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.securitylake#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1CreateDatalakeAutoEnableCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateDatalakeAutoEnableCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+exports.deserializeAws_restJson1CreateDatalakeAutoEnableCommand = deserializeAws_restJson1CreateDatalakeAutoEnableCommand;
+const deserializeAws_restJson1CreateDatalakeAutoEnableCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1CreateDatalakeDelegatedAdminCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateDatalakeDelegatedAdminCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+exports.deserializeAws_restJson1CreateDatalakeDelegatedAdminCommand = deserializeAws_restJson1CreateDatalakeDelegatedAdminCommand;
+const deserializeAws_restJson1CreateDatalakeDelegatedAdminCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+exports.deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand = deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand;
+const deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1CreateSubscriberCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateSubscriberCommandError(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.roleArn != null) {
+        contents.roleArn = (0, smithy_client_1.expectString)(data.roleArn);
+    }
+    if (data.s3BucketArn != null) {
+        contents.s3BucketArn = (0, smithy_client_1.expectString)(data.s3BucketArn);
+    }
+    if (data.snsArn != null) {
+        contents.snsArn = (0, smithy_client_1.expectString)(data.snsArn);
+    }
+    if (data.subscriptionId != null) {
+        contents.subscriptionId = (0, smithy_client_1.expectString)(data.subscriptionId);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1CreateSubscriberCommand = deserializeAws_restJson1CreateSubscriberCommand;
+const deserializeAws_restJson1CreateSubscriberCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "BucketNotFoundException":
+        case "com.amazonaws.securitylake#BucketNotFoundException":
+            throw await deserializeAws_restJson1BucketNotFoundExceptionResponse(parsedOutput, context);
+        case "ConflictSubscriptionException":
+        case "com.amazonaws.securitylake#ConflictSubscriptionException":
+            throw await deserializeAws_restJson1ConflictSubscriptionExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "InvalidInputException":
+        case "com.amazonaws.securitylake#InvalidInputException":
+            throw await deserializeAws_restJson1InvalidInputExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommandError(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.queueArn != null) {
+        contents.queueArn = (0, smithy_client_1.expectString)(data.queueArn);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand = deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand;
+const deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.securitylake#ConcurrentModificationException":
+            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "InvalidInputException":
+        case "com.amazonaws.securitylake#InvalidInputException":
+            throw await deserializeAws_restJson1InvalidInputExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1DeleteAwsLogSourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteAwsLogSourceCommandError(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);
+    }
+    if (data.processing != null) {
+        contents.processing = deserializeAws_restJson1AccountList(data.processing, context);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1DeleteAwsLogSourceCommand = deserializeAws_restJson1DeleteAwsLogSourceCommand;
+const deserializeAws_restJson1DeleteAwsLogSourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1DeleteCustomLogSourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteCustomLogSourceCommandError(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.customDataLocation != null) {
+        contents.customDataLocation = (0, smithy_client_1.expectString)(data.customDataLocation);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1DeleteCustomLogSourceCommand = deserializeAws_restJson1DeleteCustomLogSourceCommand;
+const deserializeAws_restJson1DeleteCustomLogSourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "BucketNotFoundException":
+        case "com.amazonaws.securitylake#BucketNotFoundException":
+            throw await deserializeAws_restJson1BucketNotFoundExceptionResponse(parsedOutput, context);
+        case "ConflictSourceNamesException":
+        case "com.amazonaws.securitylake#ConflictSourceNamesException":
+            throw await deserializeAws_restJson1ConflictSourceNamesExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1DeleteDatalakeCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteDatalakeCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+exports.deserializeAws_restJson1DeleteDatalakeCommand = deserializeAws_restJson1DeleteDatalakeCommand;
+const deserializeAws_restJson1DeleteDatalakeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.securitylake#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1DeleteDatalakeAutoEnableCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteDatalakeAutoEnableCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+exports.deserializeAws_restJson1DeleteDatalakeAutoEnableCommand = deserializeAws_restJson1DeleteDatalakeAutoEnableCommand;
+const deserializeAws_restJson1DeleteDatalakeAutoEnableCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+exports.deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommand = deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommand;
+const deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommandError(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.status != null) {
+        contents.status = (0, smithy_client_1.expectString)(data.status);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand = deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand;
+const deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1DeleteSubscriberCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteSubscriberCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+exports.deserializeAws_restJson1DeleteSubscriberCommand = deserializeAws_restJson1DeleteSubscriberCommand;
+const deserializeAws_restJson1DeleteSubscriberCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "BucketNotFoundException":
+        case "com.amazonaws.securitylake#BucketNotFoundException":
+            throw await deserializeAws_restJson1BucketNotFoundExceptionResponse(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.securitylake#ConcurrentModificationException":
+            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "InvalidInputException":
+        case "com.amazonaws.securitylake#InvalidInputException":
+            throw await deserializeAws_restJson1InvalidInputExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+exports.deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand = deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand;
+const deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.securitylake#ConcurrentModificationException":
+            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "InvalidInputException":
+        case "com.amazonaws.securitylake#InvalidInputException":
+            throw await deserializeAws_restJson1InvalidInputExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1GetDatalakeCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetDatalakeCommandError(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);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1GetDatalakeCommand = deserializeAws_restJson1GetDatalakeCommand;
+const deserializeAws_restJson1GetDatalakeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1GetDatalakeAutoEnableCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetDatalakeAutoEnableCommandError(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);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1GetDatalakeAutoEnableCommand = deserializeAws_restJson1GetDatalakeAutoEnableCommand;
+const deserializeAws_restJson1GetDatalakeAutoEnableCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1GetDatalakeExceptionsExpiryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetDatalakeExceptionsExpiryCommandError(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.exceptionMessageExpiry != null) {
+        contents.exceptionMessageExpiry = (0, smithy_client_1.expectLong)(data.exceptionMessageExpiry);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1GetDatalakeExceptionsExpiryCommand = deserializeAws_restJson1GetDatalakeExceptionsExpiryCommand;
+const deserializeAws_restJson1GetDatalakeExceptionsExpiryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommandError(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);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand = deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand;
+const deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1GetDatalakeStatusCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetDatalakeStatusCommandError(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);
+    }
+    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) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1GetSubscriberCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetSubscriberCommandError(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);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1GetSubscriberCommand = deserializeAws_restJson1GetSubscriberCommand;
+const deserializeAws_restJson1GetSubscriberCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "InvalidInputException":
+        case "com.amazonaws.securitylake#InvalidInputException":
+            throw await deserializeAws_restJson1InvalidInputExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1ListDatalakeExceptionsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListDatalakeExceptionsCommandError(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.nextToken != null) {
+        contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
+    }
+    if (data.nonRetryableFailures != null) {
+        contents.nonRetryableFailures = deserializeAws_restJson1FailuresResponseList(data.nonRetryableFailures, context);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1ListDatalakeExceptionsCommand = deserializeAws_restJson1ListDatalakeExceptionsCommand;
+const deserializeAws_restJson1ListDatalakeExceptionsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1ListLogSourcesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListLogSourcesCommandError(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.nextToken != null) {
+        contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
+    }
+    if (data.regionSourceTypesAccountsList != null) {
+        contents.regionSourceTypesAccountsList = deserializeAws_restJson1RegionSourceTypesAccountsList(data.regionSourceTypesAccountsList, context);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1ListLogSourcesCommand = deserializeAws_restJson1ListLogSourcesCommand;
+const deserializeAws_restJson1ListLogSourcesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1ListSubscribersCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListSubscribersCommandError(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.nextToken != null) {
+        contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
+    }
+    if (data.subscribers != null) {
+        contents.subscribers = deserializeAws_restJson1SubscriberList(data.subscribers, context);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1ListSubscribersCommand = deserializeAws_restJson1ListSubscribersCommand;
+const deserializeAws_restJson1ListSubscribersCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "InvalidInputException":
+        case "com.amazonaws.securitylake#InvalidInputException":
+            throw await deserializeAws_restJson1InvalidInputExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1UpdateDatalakeCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateDatalakeCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+exports.deserializeAws_restJson1UpdateDatalakeCommand = deserializeAws_restJson1UpdateDatalakeCommand;
+const deserializeAws_restJson1UpdateDatalakeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "EventBridgeException":
+        case "com.amazonaws.securitylake#EventBridgeException":
+            throw await deserializeAws_restJson1EventBridgeExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+exports.deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand = deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand;
+const deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+exports.deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand = deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand;
+const deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1UpdateSubscriberCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateSubscriberCommandError(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);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1UpdateSubscriberCommand = deserializeAws_restJson1UpdateSubscriberCommand;
+const deserializeAws_restJson1UpdateSubscriberCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.securitylake#ConcurrentModificationException":
+            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+        case "ConflictSubscriptionException":
+        case "com.amazonaws.securitylake#ConflictSubscriptionException":
+            throw await deserializeAws_restJson1ConflictSubscriptionExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "InvalidInputException":
+        case "com.amazonaws.securitylake#InvalidInputException":
+            throw await deserializeAws_restJson1InvalidInputExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommandError(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.queueArn != null) {
+        contents.queueArn = (0, smithy_client_1.expectString)(data.queueArn);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand = deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand;
+const deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.securitylake#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.securitylake#AccountNotFoundException":
+            throw await deserializeAws_restJson1AccountNotFoundExceptionResponse(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.securitylake#ConcurrentModificationException":
+            throw await deserializeAws_restJson1ConcurrentModificationExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.securitylake#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "InvalidInputException":
+        case "com.amazonaws.securitylake#InvalidInputException":
+            throw await deserializeAws_restJson1InvalidInputExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.securitylake#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SecurityLakeServiceException_1.SecurityLakeServiceException,
+                errorCode,
+            });
+    }
+};
+const map = smithy_client_1.map;
+const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
+    }
+    const exception = new models_0_1.AccessDeniedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1AccountNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
+    }
+    const exception = new models_0_1.AccountNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1BucketNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
+    }
+    const exception = new models_0_1.BucketNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ConcurrentModificationExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
+    }
+    const exception = new models_0_1.ConcurrentModificationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
+    }
+    if (data.resourceId != null) {
+        contents.resourceId = (0, smithy_client_1.expectString)(data.resourceId);
+    }
+    if (data.resourceType != null) {
+        contents.resourceType = (0, smithy_client_1.expectString)(data.resourceType);
+    }
+    const exception = new models_0_1.ConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ConflictSourceNamesExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
+    }
+    const exception = new models_0_1.ConflictSourceNamesException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ConflictSubscriptionExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
+    }
+    const exception = new models_0_1.ConflictSubscriptionException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1EventBridgeExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
+    }
+    const exception = new models_0_1.EventBridgeException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({
+        retryAfterSeconds: [
+            () => void 0 !== parsedOutput.headers["retry-after"],
+            () => (0, smithy_client_1.strictParseInt32)(parsedOutput.headers["retry-after"]),
+        ],
+    });
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
+    }
+    const exception = new models_0_1.InternalServerException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1InvalidInputExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
+    }
+    const exception = new models_0_1.InvalidInputException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
+    }
+    if (data.resourceId != null) {
+        contents.resourceId = (0, smithy_client_1.expectString)(data.resourceId);
+    }
+    if (data.resourceType != null) {
+        contents.resourceType = (0, smithy_client_1.expectString)(data.resourceType);
+    }
+    const exception = new models_0_1.ResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1S3ExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
+    }
+    const exception = new models_0_1.S3Exception({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ServiceQuotaExceededExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
+    }
+    if (data.quotaCode != null) {
+        contents.quotaCode = (0, smithy_client_1.expectString)(data.quotaCode);
+    }
+    if (data.resourceId != null) {
+        contents.resourceId = (0, smithy_client_1.expectString)(data.resourceId);
+    }
+    if (data.resourceType != null) {
+        contents.resourceType = (0, smithy_client_1.expectString)(data.resourceType);
+    }
+    if (data.serviceCode != null) {
+        contents.serviceCode = (0, smithy_client_1.expectString)(data.serviceCode);
+    }
+    const exception = new models_0_1.ServiceQuotaExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({
+        retryAfterSeconds: [
+            () => void 0 !== parsedOutput.headers["retry-after"],
+            () => (0, smithy_client_1.strictParseInt32)(parsedOutput.headers["retry-after"]),
+        ],
+    });
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
+    }
+    if (data.quotaCode != null) {
+        contents.quotaCode = (0, smithy_client_1.expectString)(data.quotaCode);
+    }
+    if (data.serviceCode != null) {
+        contents.serviceCode = (0, smithy_client_1.expectString)(data.serviceCode);
+    }
+    const exception = new models_0_1.ThrottlingException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.fieldList != null) {
+        contents.fieldList = deserializeAws_restJson1ValidationExceptionFieldList(data.fieldList, context);
+    }
+    if (data.message != null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
+    }
+    if (data.reason != null) {
+        contents.reason = (0, smithy_client_1.expectString)(data.reason);
+    }
+    const exception = new models_0_1.ValidationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const serializeAws_restJson1AccessTypeList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_restJson1AllDimensionsMap = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = serializeAws_restJson1TwoDimensionsMap(value, context);
+        return acc;
+    }, {});
+};
+const serializeAws_restJson1AutoEnableNewRegionConfiguration = (input, context) => {
+    return {
+        ...(input.region != null && { region: input.region }),
+        ...(input.sources != null && { sources: serializeAws_restJson1AwsSourceTypeList(input.sources, context) }),
+    };
+};
+const serializeAws_restJson1AutoEnableNewRegionConfigurationList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1AutoEnableNewRegionConfiguration(entry, context);
+    });
+};
+const serializeAws_restJson1AwsSourceTypeList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_restJson1DimensionSet = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_restJson1InputSet = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_restJson1LakeConfigurationRequest = (input, context) => {
+    return {
+        ...(input.encryptionKey != null && { encryptionKey: input.encryptionKey }),
+        ...(input.replicationDestinationRegions != null && {
+            replicationDestinationRegions: serializeAws_restJson1RegionSet(input.replicationDestinationRegions, context),
+        }),
+        ...(input.replicationRoleArn != null && { replicationRoleArn: input.replicationRoleArn }),
+        ...(input.retentionSettings != null && {
+            retentionSettings: serializeAws_restJson1RetentionSettingList(input.retentionSettings, context),
+        }),
+        ...(input.tagsMap != null && { tagsMap: serializeAws_restJson1TagsMap(input.tagsMap, context) }),
+    };
+};
+const serializeAws_restJson1LakeConfigurationRequestMap = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = serializeAws_restJson1LakeConfigurationRequest(value, context);
+        return acc;
+    }, {});
+};
+const serializeAws_restJson1RegionSet = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_restJson1RetentionSetting = (input, context) => {
+    return {
+        ...(input.retentionPeriod != null && { retentionPeriod: input.retentionPeriod }),
+        ...(input.storageClass != null && { storageClass: input.storageClass }),
+    };
+};
+const serializeAws_restJson1RetentionSettingList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1RetentionSetting(entry, context);
+    });
+};
+const serializeAws_restJson1SourceType = (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) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1SourceType(entry, context);
+    });
+};
+const serializeAws_restJson1TagsMap = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = value;
+        return acc;
+    }, {});
+};
+const serializeAws_restJson1TwoDimensionsMap = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = serializeAws_restJson1ValueSet(value, context);
+        return acc;
+    }, {});
+};
+const serializeAws_restJson1ValueSet = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const deserializeAws_restJson1AccessTypeList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return (0, smithy_client_1.expectString)(entry);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1AccountList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return (0, smithy_client_1.expectString)(entry);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1AccountSources = (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,
+        sourceType: (0, smithy_client_1.expectString)(output.sourceType),
+    };
+};
+const deserializeAws_restJson1AccountSourcesList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1AccountSources(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1AllDimensionsMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = deserializeAws_restJson1TwoDimensionsMap(value, context);
+        return acc;
+    }, {});
+};
+const deserializeAws_restJson1AutoEnableNewRegionConfiguration = (output, context) => {
+    return {
+        region: (0, smithy_client_1.expectString)(output.region),
+        sources: output.sources != null ? deserializeAws_restJson1AwsSourceTypeList(output.sources, context) : undefined,
+    };
+};
+const deserializeAws_restJson1AutoEnableNewRegionConfigurationList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1AutoEnableNewRegionConfiguration(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1AwsSourceTypeList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return (0, smithy_client_1.expectString)(entry);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1Failures = (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.parseRfc3339DateTime)(output.timestamp)) : undefined,
+    };
+};
+const deserializeAws_restJson1Failureslist = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1Failures(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1FailuresResponse = (output, context) => {
+    return {
+        failures: output.failures != null ? deserializeAws_restJson1Failureslist(output.failures, context) : undefined,
+        region: (0, smithy_client_1.expectString)(output.region),
+    };
+};
+const deserializeAws_restJson1FailuresResponseList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1FailuresResponse(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1LakeConfigurationResponse = (output, context) => {
+    return {
+        encryptionKey: (0, smithy_client_1.expectString)(output.encryptionKey),
+        replicationDestinationRegions: output.replicationDestinationRegions != null
+            ? deserializeAws_restJson1RegionSet(output.replicationDestinationRegions, context)
+            : undefined,
+        replicationRoleArn: (0, smithy_client_1.expectString)(output.replicationRoleArn),
+        retentionSettings: output.retentionSettings != null
+            ? deserializeAws_restJson1RetentionSettingList(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,
+    };
+};
+const deserializeAws_restJson1LakeConfigurationResponseMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = deserializeAws_restJson1LakeConfigurationResponse(value, context);
+        return acc;
+    }, {});
+};
+const deserializeAws_restJson1LogsStatus = (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 retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1LogsStatus(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1ProtocolAndNotificationEndpoint = (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 retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return (0, smithy_client_1.expectString)(entry);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1RegionSourceTypesAccountsList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1AllDimensionsMap(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1RetentionSetting = (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 retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1RetentionSetting(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1SourceType = (output, context) => {
+    if ((0, smithy_client_1.expectString)(output.awsSourceType) !== undefined) {
+        return { awsSourceType: (0, smithy_client_1.expectString)(output.awsSourceType) };
+    }
+    if ((0, smithy_client_1.expectString)(output.customSourceType) !== undefined) {
+        return { customSourceType: (0, smithy_client_1.expectString)(output.customSourceType) };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const deserializeAws_restJson1SourceTypeList = (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 retVal;
+};
+const deserializeAws_restJson1SubscriberList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1SubscriberResource(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1SubscriberResource = (output, context) => {
+    return {
+        accessTypes: output.accessTypes != null ? deserializeAws_restJson1AccessTypeList(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.parseRfc3339DateTime)(output.createdAt)) : undefined,
+        externalId: (0, smithy_client_1.expectString)(output.externalId),
+        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,
+        subscriberDescription: (0, smithy_client_1.expectString)(output.subscriberDescription),
+        subscriberName: (0, smithy_client_1.expectString)(output.subscriberName),
+        subscriptionEndpoint: (0, smithy_client_1.expectString)(output.subscriptionEndpoint),
+        subscriptionId: (0, smithy_client_1.expectString)(output.subscriptionId),
+        subscriptionProtocol: (0, smithy_client_1.expectString)(output.subscriptionProtocol),
+        subscriptionStatus: (0, smithy_client_1.expectString)(output.subscriptionStatus),
+        updatedAt: output.updatedAt != null ? (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTime)(output.updatedAt)) : undefined,
+    };
+};
+const deserializeAws_restJson1TagsMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = (0, smithy_client_1.expectString)(value);
+        return acc;
+    }, {});
+};
+const deserializeAws_restJson1TwoDimensionsMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = deserializeAws_restJson1ValueSet(value, context);
+        return acc;
+    }, {});
+};
+const deserializeAws_restJson1ValidationExceptionField = (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 retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ValidationExceptionField(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1ValueSet = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return (0, smithy_client_1.expectString)(entry);
+    });
+    return retVal;
+};
+const deserializeMetadata = (output) => ({
+    httpStatusCode: output.statusCode,
+    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+    extendedRequestId: output.headers["x-amz-id-2"],
+    cfId: output.headers["x-amz-cf-id"],
+});
+const collectBody = (streamBody = new Uint8Array(), context) => {
+    if (streamBody instanceof Uint8Array) {
+        return Promise.resolve(streamBody);
+    }
+    return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
+};
+const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
+const isSerializableHeaderValue = (value) => value !== undefined &&
+    value !== null &&
+    value !== "" &&
+    (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
+    (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+    if (encoded.length) {
+        return JSON.parse(encoded);
+    }
+    return {};
+});
+const parseErrorBody = async (errorBody, context) => {
+    const value = await parseBody(errorBody, context);
+    value.message = value.message ?? value.Message;
+    return value;
+};
+const loadRestJsonErrorCode = (output, data) => {
+    const findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());
+    const sanitizeErrorCode = (rawValue) => {
+        let cleanValue = rawValue;
+        if (typeof cleanValue === "number") {
+            cleanValue = cleanValue.toString();
+        }
+        if (cleanValue.indexOf(",") >= 0) {
+            cleanValue = cleanValue.split(",")[0];
+        }
+        if (cleanValue.indexOf(":") >= 0) {
+            cleanValue = cleanValue.split(":")[0];
+        }
+        if (cleanValue.indexOf("#") >= 0) {
+            cleanValue = cleanValue.split("#")[1];
+        }
+        return cleanValue;
+    };
+    const headerKey = findKey(output.headers, "x-amzn-errortype");
+    if (headerKey !== undefined) {
+        return sanitizeErrorCode(output.headers[headerKey]);
+    }
+    if (data.code !== undefined) {
+        return sanitizeErrorCode(data.code);
+    }
+    if (data["__type"] !== undefined) {
+        return sanitizeErrorCode(data["__type"]);
+    }
+};