@aws-sdk/client-securitylake 3.341.0 → 3.344.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,19 +1,16 @@
 import { _json, decorateServiceException as __decorateServiceException, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, strictParseInt32 as __strictParseInt32, take, withBaseException, } from "@aws-sdk/smithy-client";
 import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
-import { AccessDeniedException, AccountNotFoundException, BucketNotFoundException, ConcurrentModificationException, ConflictException, ConflictSourceNamesException, ConflictSubscriptionException, EventBridgeException, InternalServerException, InvalidInputException, ResourceNotFoundException, S3Exception, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
+import { AccessDeniedException, BadRequestException, ConflictException, InternalServerException, ResourceNotFoundException, ThrottlingException, } from "../models/models_0";
 import { SecurityLakeServiceException as __BaseException } from "../models/SecurityLakeServiceException";
 export const se_CreateAwsLogSourceCommand = 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";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/logsources/aws";
     let body;
     body = JSON.stringify(take(input, {
-        enableAllDimensions: (_) => _json(_),
-        enableSingleDimension: (_) => _json(_),
-        enableTwoDimensions: (_) => _json(_),
-        inputOrder: (_) => _json(_),
+        sources: (_) => _json(_),
     }));
     return new __HttpRequest({
         protocol,
@@ -30,13 +27,13 @@ export const se_CreateCustomLogSourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/logsources/custom";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/logsources/custom";
     let body;
     body = JSON.stringify(take(input, {
-        customSourceName: [],
-        eventClass: [],
-        glueInvocationRoleArn: [],
-        logProviderAccountId: [],
+        configuration: (_) => _json(_),
+        eventClasses: (_) => _json(_),
+        sourceName: [],
+        sourceVersion: [],
     }));
     return new __HttpRequest({
         protocol,
@@ -48,7 +45,7 @@ export const se_CreateCustomLogSourceCommand = async (input, context) => {
         body,
     });
 };
-export const se_CreateDatalakeCommand = async (input, context) => {
+export const se_CreateDataLakeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -57,29 +54,7 @@ export const se_CreateDatalakeCommand = async (input, context) => {
     let body;
     body = JSON.stringify(take(input, {
         configurations: (_) => _json(_),
-        enableAll: [],
         metaStoreManagerRoleArn: [],
-        regions: (_) => _json(_),
-    }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
-};
-export const se_CreateDatalakeAutoEnableCommand = 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(take(input, {
-        configurationForNewAccounts: (_) => _json(_),
     }));
     return new __HttpRequest({
         protocol,
@@ -91,15 +66,17 @@ export const se_CreateDatalakeAutoEnableCommand = async (input, context) => {
         body,
     });
 };
-export const se_CreateDatalakeDelegatedAdminCommand = async (input, context) => {
+export const se_CreateDataLakeExceptionSubscriptionCommand = 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";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/exceptions/subscription";
     let body;
     body = JSON.stringify(take(input, {
-        account: [],
+        exceptionTimeToLive: [],
+        notificationEndpoint: [],
+        subscriptionProtocol: [],
     }));
     return new __HttpRequest({
         protocol,
@@ -111,16 +88,15 @@ export const se_CreateDatalakeDelegatedAdminCommand = async (input, context) =>
         body,
     });
 };
-export const se_CreateDatalakeExceptionsSubscriptionCommand = async (input, context) => {
+export const se_CreateDataLakeOrganizationConfigurationCommand = 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";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/organization/configuration";
     let body;
     body = JSON.stringify(take(input, {
-        notificationEndpoint: [],
-        subscriptionProtocol: [],
+        autoEnableNewAccount: (_) => _json(_),
     }));
     return new __HttpRequest({
         protocol,
@@ -141,10 +117,9 @@ export const se_CreateSubscriberCommand = async (input, context) => {
     let body;
     body = JSON.stringify(take(input, {
         accessTypes: (_) => _json(_),
-        accountId: [],
-        externalId: [],
-        sourceTypes: (_) => _json(_),
+        sources: (_) => _json(_),
         subscriberDescription: [],
+        subscriberIdentity: (_) => _json(_),
         subscriberName: [],
     }));
     return new __HttpRequest({
@@ -157,22 +132,17 @@ export const se_CreateSubscriberCommand = async (input, context) => {
         body,
     });
 };
-export const se_CreateSubscriptionNotificationConfigurationCommand = async (input, context) => {
+export const se_CreateSubscriberNotificationCommand = 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 = __resolvedPath(resolvedPath, input, "subscriptionId", () => input.subscriptionId, "{subscriptionId}", false);
+        "/v1/subscribers/{subscriberId}/notification";
+    resolvedPath = __resolvedPath(resolvedPath, input, "subscriberId", () => input.subscriberId, "{subscriberId}", false);
     let body;
     body = JSON.stringify(take(input, {
-        createSqs: [],
-        httpsApiKeyName: [],
-        httpsApiKeyValue: [],
-        httpsMethod: [],
-        roleArn: [],
-        subscriptionEndpoint: [],
+        configuration: (_) => _json(_),
     }));
     return new __HttpRequest({
         protocol,
@@ -189,13 +159,10 @@ export const se_DeleteAwsLogSourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/logsources/aws/delete";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/logsources/aws/delete";
     let body;
     body = JSON.stringify(take(input, {
-        disableAllDimensions: (_) => _json(_),
-        disableSingleDimension: (_) => _json(_),
-        disableTwoDimensions: (_) => _json(_),
-        inputOrder: (_) => _json(_),
+        sources: (_) => _json(_),
     }));
     return new __HttpRequest({
         protocol,
@@ -210,9 +177,11 @@ export const se_DeleteAwsLogSourceCommand = async (input, context) => {
 export const se_DeleteCustomLogSourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/logsources/custom";
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/datalake/logsources/custom/{sourceName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "sourceName", () => input.sourceName, "{sourceName}", false);
     const query = map({
-        customSourceName: [, __expectNonNull(input.customSourceName, `customSourceName`)],
+        sourceVersion: [, input.sourceVersion],
     });
     let body;
     return new __HttpRequest({
@@ -226,33 +195,15 @@ export const se_DeleteCustomLogSourceCommand = async (input, context) => {
         body,
     });
 };
-export const se_DeleteDatalakeCommand = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
-};
-export const se_DeleteDatalakeAutoEnableCommand = async (input, context) => {
+export const se_DeleteDataLakeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/autoenable/delete";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/delete";
     let body;
     body = JSON.stringify(take(input, {
-        removeFromConfigurationForNewAccounts: (_) => _json(_),
+        regions: (_) => _json(_),
     }));
     return new __HttpRequest({
         protocol,
@@ -264,12 +215,14 @@ export const se_DeleteDatalakeAutoEnableCommand = async (input, context) => {
         body,
     });
 };
-export const se_DeleteDatalakeDelegatedAdminCommand = async (input, context) => {
+export const se_DeleteDataLakeExceptionSubscriptionCommand = 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 = __resolvedPath(resolvedPath, input, "account", () => input.account, "{account}", false);
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/exceptions/subscription";
     let body;
+    body = "";
     return new __HttpRequest({
         protocol,
         hostname,
@@ -280,19 +233,22 @@ export const se_DeleteDatalakeDelegatedAdminCommand = async (input, context) =>
         body,
     });
 };
-export const se_DeleteDatalakeExceptionsSubscriptionCommand = async (input, context) => {
+export const se_DeleteDataLakeOrganizationConfigurationCommand = 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";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/datalake/organization/configuration/delete";
     let body;
-    body = "";
+    body = JSON.stringify(take(input, {
+        autoEnableNewAccount: (_) => _json(_),
+    }));
     return new __HttpRequest({
         protocol,
         hostname,
         port,
-        method: "DELETE",
+        method: "POST",
         headers,
         path: resolvedPath,
         body,
@@ -301,10 +257,8 @@ export const se_DeleteDatalakeExceptionsSubscriptionCommand = async (input, cont
 export const se_DeleteSubscriberCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/subscribers";
-    const query = map({
-        id: [, __expectNonNull(input.id, `id`)],
-    });
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/subscribers/{subscriberId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "subscriberId", () => input.subscriberId, "{subscriberId}", false);
     let body;
     return new __HttpRequest({
         protocol,
@@ -313,16 +267,15 @@ export const se_DeleteSubscriberCommand = async (input, context) => {
         method: "DELETE",
         headers,
         path: resolvedPath,
-        query,
         body,
     });
 };
-export const se_DeleteSubscriptionNotificationConfigurationCommand = async (input, context) => {
+export const se_DeleteSubscriberNotificationCommand = 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 = __resolvedPath(resolvedPath, input, "subscriptionId", () => input.subscriptionId, "{subscriptionId}", false);
+        "/v1/subscribers/{subscriberId}/notification";
+    resolvedPath = __resolvedPath(resolvedPath, input, "subscriberId", () => input.subscriberId, "{subscriberId}", false);
     let body;
     return new __HttpRequest({
         protocol,
@@ -334,48 +287,30 @@ export const se_DeleteSubscriptionNotificationConfigurationCommand = async (inpu
         body,
     });
 };
-export const se_GetDatalakeCommand = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
-};
-export const se_GetDatalakeAutoEnableCommand = async (input, context) => {
+export const se_DeregisterDataLakeDelegatedAdministratorCommand = 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";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/delegate";
     let body;
     body = "";
     return new __HttpRequest({
         protocol,
         hostname,
         port,
-        method: "GET",
+        method: "DELETE",
         headers,
         path: resolvedPath,
         body,
     });
 };
-export const se_GetDatalakeExceptionsExpiryCommand = async (input, context) => {
+export const se_GetDataLakeExceptionSubscriptionCommand = 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";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/exceptions/subscription";
     let body;
     body = "";
     return new __HttpRequest({
@@ -388,12 +323,12 @@ export const se_GetDatalakeExceptionsExpiryCommand = async (input, context) => {
         body,
     });
 };
-export const se_GetDatalakeExceptionsSubscriptionCommand = async (input, context) => {
+export const se_GetDataLakeOrganizationConfigurationCommand = 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";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/organization/configuration";
     let body;
     body = "";
     return new __HttpRequest({
@@ -406,16 +341,16 @@ export const se_GetDatalakeExceptionsSubscriptionCommand = async (input, context
         body,
     });
 };
-export const se_GetDatalakeStatusCommand = async (input, context) => {
+export const se_GetDataLakeSourcesCommand = 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";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/sources";
     let body;
     body = JSON.stringify(take(input, {
-        accountSet: (_) => _json(_),
-        maxAccountResults: [],
+        accounts: (_) => _json(_),
+        maxResults: [],
         nextToken: [],
     }));
     return new __HttpRequest({
@@ -431,8 +366,8 @@ export const se_GetDatalakeStatusCommand = async (input, context) => {
 export const se_GetSubscriberCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/subscribers/{id}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/subscribers/{subscriberId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "subscriberId", () => input.subscriberId, "{subscriberId}", false);
     let body;
     return new __HttpRequest({
         protocol,
@@ -444,7 +379,7 @@ export const se_GetSubscriberCommand = async (input, context) => {
         body,
     });
 };
-export const se_ListDatalakeExceptionsCommand = async (input, context) => {
+export const se_ListDataLakeExceptionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -452,9 +387,9 @@ export const se_ListDatalakeExceptionsCommand = async (input, context) => {
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/exceptions";
     let body;
     body = JSON.stringify(take(input, {
-        maxFailures: [],
+        maxResults: [],
         nextToken: [],
-        regionSet: (_) => _json(_),
+        regions: (_) => _json(_),
     }));
     return new __HttpRequest({
         protocol,
@@ -466,20 +401,38 @@ export const se_ListDatalakeExceptionsCommand = async (input, context) => {
         body,
     });
 };
+export const se_ListDataLakesCommand = 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/datalakes";
+    const query = map({
+        regions: [() => input.regions !== void 0, () => (input.regions || []).map((_entry) => _entry)],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_ListLogSourcesCommand = 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";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/logsources/list";
     let body;
     body = JSON.stringify(take(input, {
-        inputOrder: (_) => _json(_),
-        listAllDimensions: (_) => _json(_),
-        listSingleDimension: (_) => _json(_),
-        listTwoDimensions: (_) => _json(_),
+        accounts: (_) => _json(_),
         maxResults: [],
         nextToken: [],
+        regions: (_) => _json(_),
+        sources: (_) => _json(_),
     }));
     return new __HttpRequest({
         protocol,
@@ -511,35 +464,35 @@ export const se_ListSubscribersCommand = async (input, context) => {
         body,
     });
 };
-export const se_UpdateDatalakeCommand = async (input, context) => {
+export const se_RegisterDataLakeDelegatedAdministratorCommand = 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";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/delegate";
     let body;
     body = JSON.stringify(take(input, {
-        configurations: (_) => _json(_),
+        accountId: [],
     }));
     return new __HttpRequest({
         protocol,
         hostname,
         port,
-        method: "PUT",
+        method: "POST",
         headers,
         path: resolvedPath,
         body,
     });
 };
-export const se_UpdateDatalakeExceptionsExpiryCommand = async (input, context) => {
+export const se_UpdateDataLakeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/exceptions/expiry";
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake";
     let body;
     body = JSON.stringify(take(input, {
-        exceptionMessageExpiry: [],
+        configurations: (_) => _json(_),
     }));
     return new __HttpRequest({
         protocol,
@@ -551,7 +504,7 @@ export const se_UpdateDatalakeExceptionsExpiryCommand = async (input, context) =
         body,
     });
 };
-export const se_UpdateDatalakeExceptionsSubscriptionCommand = async (input, context) => {
+export const se_UpdateDataLakeExceptionSubscriptionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -559,6 +512,7 @@ export const se_UpdateDatalakeExceptionsSubscriptionCommand = async (input, cont
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datalake/exceptions/subscription";
     let body;
     body = JSON.stringify(take(input, {
+        exceptionTimeToLive: [],
         notificationEndpoint: [],
         subscriptionProtocol: [],
     }));
@@ -577,13 +531,13 @@ export const se_UpdateSubscriberCommand = async (input, context) => {
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/subscribers/{id}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/subscribers/{subscriberId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "subscriberId", () => input.subscriberId, "{subscriberId}", false);
     let body;
     body = JSON.stringify(take(input, {
-        externalId: [],
-        sourceTypes: (_) => _json(_),
+        sources: (_) => _json(_),
         subscriberDescription: [],
+        subscriberIdentity: (_) => _json(_),
         subscriberName: [],
     }));
     return new __HttpRequest({
@@ -596,22 +550,17 @@ export const se_UpdateSubscriberCommand = async (input, context) => {
         body,
     });
 };
-export const se_UpdateSubscriptionNotificationConfigurationCommand = async (input, context) => {
+export const se_UpdateSubscriberNotificationCommand = 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 = __resolvedPath(resolvedPath, input, "subscriptionId", () => input.subscriptionId, "{subscriptionId}", false);
+        "/v1/subscribers/{subscriberId}/notification";
+    resolvedPath = __resolvedPath(resolvedPath, input, "subscriberId", () => input.subscriberId, "{subscriberId}", false);
     let body;
     body = JSON.stringify(take(input, {
-        createSqs: [],
-        httpsApiKeyName: [],
-        httpsApiKeyValue: [],
-        httpsMethod: [],
-        roleArn: [],
-        subscriptionEndpoint: [],
+        configuration: (_) => _json(_),
     }));
     return new __HttpRequest({
         protocol,
@@ -633,7 +582,6 @@ export const de_CreateAwsLogSourceCommand = async (output, context) => {
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
         failed: _json,
-        processing: _json,
     });
     Object.assign(contents, doc);
     return contents;
@@ -648,21 +596,21 @@ const de_CreateAwsLogSourceCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "S3Exception":
-        case "com.amazonaws.securitylake#S3Exception":
-            throw await de_S3ExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -681,11 +629,7 @@ export const de_CreateCustomLogSourceCommand = async (output, context) => {
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        customDataLocation: __expectString,
-        glueCrawlerName: __expectString,
-        glueDatabaseName: __expectString,
-        glueTableName: __expectString,
-        logProviderAccessRoleArn: __expectString,
+        source: _json,
     });
     Object.assign(contents, doc);
     return contents;
@@ -700,24 +644,21 @@ const de_CreateCustomLogSourceCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
-        case "BucketNotFoundException":
-        case "com.amazonaws.securitylake#BucketNotFoundException":
-            throw await de_BucketNotFoundExceptionRes(parsedOutput, context);
-        case "ConflictSourceNamesException":
-        case "com.amazonaws.securitylake#ConflictSourceNamesException":
-            throw await de_ConflictSourceNamesExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -727,17 +668,21 @@ const de_CreateCustomLogSourceCommandError = async (output, context) => {
             });
     }
 };
-export const de_CreateDatalakeCommand = async (output, context) => {
+export const de_CreateDataLakeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateDatalakeCommandError(output, context);
+        return de_CreateDataLakeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    await collectBody(output.body, context);
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        dataLakes: _json,
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_CreateDatalakeCommandError = async (output, context) => {
+const de_CreateDataLakeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -747,6 +692,9 @@ const de_CreateDatalakeCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.securitylake#ConflictException":
             throw await de_ConflictExceptionRes(parsedOutput, context);
@@ -756,15 +704,9 @@ const de_CreateDatalakeCommandError = async (output, context) => {
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.securitylake#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.securitylake#ThrottlingException":
             throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -774,9 +716,9 @@ const de_CreateDatalakeCommandError = async (output, context) => {
             });
     }
 };
-export const de_CreateDatalakeAutoEnableCommand = async (output, context) => {
+export const de_CreateDataLakeExceptionSubscriptionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateDatalakeAutoEnableCommandError(output, context);
+        return de_CreateDataLakeExceptionSubscriptionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -784,45 +726,7 @@ export const de_CreateDatalakeAutoEnableCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_CreateDatalakeAutoEnableCommandError = 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 de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.securitylake#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_CreateDatalakeDelegatedAdminCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateDatalakeDelegatedAdminCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
-    });
-    await collectBody(output.body, context);
-    return contents;
-};
-const de_CreateDatalakeDelegatedAdminCommandError = async (output, context) => {
+const de_CreateDataLakeExceptionSubscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -832,15 +736,21 @@ const de_CreateDatalakeDelegatedAdminCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.securitylake#ThrottlingException":
             throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -850,9 +760,9 @@ const de_CreateDatalakeDelegatedAdminCommandError = async (output, context) => {
             });
     }
 };
-export const de_CreateDatalakeExceptionsSubscriptionCommand = async (output, context) => {
+export const de_CreateDataLakeOrganizationConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateDatalakeExceptionsSubscriptionCommandError(output, context);
+        return de_CreateDataLakeOrganizationConfigurationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -860,7 +770,7 @@ export const de_CreateDatalakeExceptionsSubscriptionCommand = async (output, con
     await collectBody(output.body, context);
     return contents;
 };
-const de_CreateDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
+const de_CreateDataLakeOrganizationConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -870,15 +780,21 @@ const de_CreateDatalakeExceptionsSubscriptionCommandError = async (output, conte
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -897,12 +813,7 @@ export const de_CreateSubscriberCommand = async (output, context) => {
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        resourceShareArn: __expectString,
-        resourceShareName: __expectString,
-        roleArn: __expectString,
-        s3BucketArn: __expectString,
-        snsArn: __expectString,
-        subscriptionId: __expectString,
+        subscriber: (_) => de_SubscriberResource(_, context),
     });
     Object.assign(contents, doc);
     return contents;
@@ -917,27 +828,21 @@ const de_CreateSubscriberCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
-        case "BucketNotFoundException":
-        case "com.amazonaws.securitylake#BucketNotFoundException":
-            throw await de_BucketNotFoundExceptionRes(parsedOutput, context);
-        case "ConflictSubscriptionException":
-        case "com.amazonaws.securitylake#ConflictSubscriptionException":
-            throw await de_ConflictSubscriptionExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "InvalidInputException":
-        case "com.amazonaws.securitylake#InvalidInputException":
-            throw await de_InvalidInputExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -947,21 +852,21 @@ const de_CreateSubscriberCommandError = async (output, context) => {
             });
     }
 };
-export const de_CreateSubscriptionNotificationConfigurationCommand = async (output, context) => {
+export const de_CreateSubscriberNotificationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateSubscriptionNotificationConfigurationCommandError(output, context);
+        return de_CreateSubscriberNotificationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        queueArn: __expectString,
+        subscriberEndpoint: __expectString,
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateSubscriptionNotificationConfigurationCommandError = async (output, context) => {
+const de_CreateSubscriberNotificationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -971,24 +876,21 @@ const de_CreateSubscriptionNotificationConfigurationCommandError = async (output
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
-        case "ConcurrentModificationException":
-        case "com.amazonaws.securitylake#ConcurrentModificationException":
-            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "InvalidInputException":
-        case "com.amazonaws.securitylake#InvalidInputException":
-            throw await de_InvalidInputExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1008,7 +910,6 @@ export const de_DeleteAwsLogSourceCommand = async (output, context) => {
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
         failed: _json,
-        processing: _json,
     });
     Object.assign(contents, doc);
     return contents;
@@ -1023,15 +924,21 @@ const de_DeleteAwsLogSourceCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1048,11 +955,7 @@ export const de_DeleteCustomLogSourceCommand = async (output, context) => {
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    const doc = take(data, {
-        customDataLocation: __expectString,
-    });
-    Object.assign(contents, doc);
+    await collectBody(output.body, context);
     return contents;
 };
 const de_DeleteCustomLogSourceCommandError = async (output, context) => {
@@ -1065,24 +968,21 @@ const de_DeleteCustomLogSourceCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
-        case "BucketNotFoundException":
-        case "com.amazonaws.securitylake#BucketNotFoundException":
-            throw await de_BucketNotFoundExceptionRes(parsedOutput, context);
-        case "ConflictSourceNamesException":
-        case "com.amazonaws.securitylake#ConflictSourceNamesException":
-            throw await de_ConflictSourceNamesExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1092,9 +992,9 @@ const de_DeleteCustomLogSourceCommandError = async (output, context) => {
             });
     }
 };
-export const de_DeleteDatalakeCommand = async (output, context) => {
+export const de_DeleteDataLakeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteDatalakeCommandError(output, context);
+        return de_DeleteDataLakeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1102,7 +1002,7 @@ export const de_DeleteDatalakeCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteDatalakeCommandError = async (output, context) => {
+const de_DeleteDataLakeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1112,6 +1012,9 @@ const de_DeleteDatalakeCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.securitylake#ConflictException":
             throw await de_ConflictExceptionRes(parsedOutput, context);
@@ -1121,15 +1024,9 @@ const de_DeleteDatalakeCommandError = async (output, context) => {
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.securitylake#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.securitylake#ThrottlingException":
             throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1139,9 +1036,9 @@ const de_DeleteDatalakeCommandError = async (output, context) => {
             });
     }
 };
-export const de_DeleteDatalakeAutoEnableCommand = async (output, context) => {
+export const de_DeleteDataLakeExceptionSubscriptionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteDatalakeAutoEnableCommandError(output, context);
+        return de_DeleteDataLakeExceptionSubscriptionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1149,7 +1046,7 @@ export const de_DeleteDatalakeAutoEnableCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteDatalakeAutoEnableCommandError = async (output, context) => {
+const de_DeleteDataLakeExceptionSubscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1159,15 +1056,21 @@ const de_DeleteDatalakeAutoEnableCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1177,9 +1080,9 @@ const de_DeleteDatalakeAutoEnableCommandError = async (output, context) => {
             });
     }
 };
-export const de_DeleteDatalakeDelegatedAdminCommand = async (output, context) => {
+export const de_DeleteDataLakeOrganizationConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteDatalakeDelegatedAdminCommandError(output, context);
+        return de_DeleteDataLakeOrganizationConfigurationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1187,7 +1090,7 @@ export const de_DeleteDatalakeDelegatedAdminCommand = async (output, context) =>
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteDatalakeDelegatedAdminCommandError = async (output, context) => {
+const de_DeleteDataLakeOrganizationConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1197,15 +1100,21 @@ const de_DeleteDatalakeDelegatedAdminCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.securitylake#ThrottlingException":
             throw await de_ThrottlingExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1215,21 +1124,17 @@ const de_DeleteDatalakeDelegatedAdminCommandError = async (output, context) => {
             });
     }
 };
-export const de_DeleteDatalakeExceptionsSubscriptionCommand = async (output, context) => {
+export const de_DeleteSubscriberCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteDatalakeExceptionsSubscriptionCommandError(output, context);
+        return de_DeleteSubscriberCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    const doc = take(data, {
-        status: __expectString,
-    });
-    Object.assign(contents, doc);
+    await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
+const de_DeleteSubscriberCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1239,15 +1144,21 @@ const de_DeleteDatalakeExceptionsSubscriptionCommandError = async (output, conte
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1257,9 +1168,9 @@ const de_DeleteDatalakeExceptionsSubscriptionCommandError = async (output, conte
             });
     }
 };
-export const de_DeleteSubscriberCommand = async (output, context) => {
+export const de_DeleteSubscriberNotificationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteSubscriberCommandError(output, context);
+        return de_DeleteSubscriberNotificationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1267,7 +1178,7 @@ export const de_DeleteSubscriberCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteSubscriberCommandError = async (output, context) => {
+const de_DeleteSubscriberNotificationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1277,27 +1188,21 @@ const de_DeleteSubscriberCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
-        case "BucketNotFoundException":
-        case "com.amazonaws.securitylake#BucketNotFoundException":
-            throw await de_BucketNotFoundExceptionRes(parsedOutput, context);
-        case "ConcurrentModificationException":
-        case "com.amazonaws.securitylake#ConcurrentModificationException":
-            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "InvalidInputException":
-        case "com.amazonaws.securitylake#InvalidInputException":
-            throw await de_InvalidInputExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1307,9 +1212,9 @@ const de_DeleteSubscriberCommandError = async (output, context) => {
             });
     }
 };
-export const de_DeleteSubscriptionNotificationConfigurationCommand = async (output, context) => {
+export const de_DeregisterDataLakeDelegatedAdministratorCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteSubscriptionNotificationConfigurationCommandError(output, context);
+        return de_DeregisterDataLakeDelegatedAdministratorCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1317,7 +1222,7 @@ export const de_DeleteSubscriptionNotificationConfigurationCommand = async (outp
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteSubscriptionNotificationConfigurationCommandError = async (output, context) => {
+const de_DeregisterDataLakeDelegatedAdministratorCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1327,24 +1232,21 @@ const de_DeleteSubscriptionNotificationConfigurationCommandError = async (output
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
-        case "ConcurrentModificationException":
-        case "com.amazonaws.securitylake#ConcurrentModificationException":
-            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "InvalidInputException":
-        case "com.amazonaws.securitylake#InvalidInputException":
-            throw await de_InvalidInputExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1354,21 +1256,23 @@ const de_DeleteSubscriptionNotificationConfigurationCommandError = async (output
             });
     }
 };
-export const de_GetDatalakeCommand = async (output, context) => {
+export const de_GetDataLakeExceptionSubscriptionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetDatalakeCommandError(output, context);
+        return de_GetDataLakeExceptionSubscriptionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        configurations: _json,
+        exceptionTimeToLive: __expectLong,
+        notificationEndpoint: __expectString,
+        subscriptionProtocol: __expectString,
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetDatalakeCommandError = async (output, context) => {
+const de_GetDataLakeExceptionSubscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1378,18 +1282,21 @@ const de_GetDatalakeCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1399,21 +1306,21 @@ const de_GetDatalakeCommandError = async (output, context) => {
             });
     }
 };
-export const de_GetDatalakeAutoEnableCommand = async (output, context) => {
+export const de_GetDataLakeOrganizationConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetDatalakeAutoEnableCommandError(output, context);
+        return de_GetDataLakeOrganizationConfigurationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        autoEnableNewAccounts: _json,
+        autoEnableNewAccount: _json,
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetDatalakeAutoEnableCommandError = async (output, context) => {
+const de_GetDataLakeOrganizationConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1423,15 +1330,21 @@ const de_GetDatalakeAutoEnableCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1441,21 +1354,23 @@ const de_GetDatalakeAutoEnableCommandError = async (output, context) => {
             });
     }
 };
-export const de_GetDatalakeExceptionsExpiryCommand = async (output, context) => {
+export const de_GetDataLakeSourcesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetDatalakeExceptionsExpiryCommandError(output, context);
+        return de_GetDataLakeSourcesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        exceptionMessageExpiry: __expectLong,
+        dataLakeArn: __expectString,
+        dataLakeSources: _json,
+        nextToken: __expectString,
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetDatalakeExceptionsExpiryCommandError = async (output, context) => {
+const de_GetDataLakeSourcesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1465,15 +1380,21 @@ const de_GetDatalakeExceptionsExpiryCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1483,21 +1404,21 @@ const de_GetDatalakeExceptionsExpiryCommandError = async (output, context) => {
             });
     }
 };
-export const de_GetDatalakeExceptionsSubscriptionCommand = async (output, context) => {
+export const de_GetSubscriberCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetDatalakeExceptionsSubscriptionCommandError(output, context);
+        return de_GetSubscriberCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        protocolAndNotificationEndpoint: _json,
+        subscriber: (_) => de_SubscriberResource(_, context),
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
+const de_GetSubscriberCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1507,15 +1428,21 @@ const de_GetDatalakeExceptionsSubscriptionCommandError = async (output, context)
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1525,22 +1452,22 @@ const de_GetDatalakeExceptionsSubscriptionCommandError = async (output, context)
             });
     }
 };
-export const de_GetDatalakeStatusCommand = async (output, context) => {
+export const de_ListDataLakeExceptionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetDatalakeStatusCommandError(output, context);
+        return de_ListDataLakeExceptionsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        accountSourcesList: _json,
+        exceptions: (_) => de_DataLakeExceptionList(_, context),
         nextToken: __expectString,
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetDatalakeStatusCommandError = async (output, context) => {
+const de_ListDataLakeExceptionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1550,60 +1477,21 @@ const de_GetDatalakeStatusCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.securitylake#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetSubscriberCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetSubscriberCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    const doc = take(data, {
-        subscriber: (_) => de_SubscriberResource(_, context),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetSubscriberCommandError = 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 de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "InvalidInputException":
-        case "com.amazonaws.securitylake#InvalidInputException":
-            throw await de_InvalidInputExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1613,22 +1501,21 @@ const de_GetSubscriberCommandError = async (output, context) => {
             });
     }
 };
-export const de_ListDatalakeExceptionsCommand = async (output, context) => {
+export const de_ListDataLakesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListDatalakeExceptionsCommandError(output, context);
+        return de_ListDataLakesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        nextToken: __expectString,
-        nonRetryableFailures: (_) => de_FailuresResponseList(_, context),
+        dataLakes: _json,
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListDatalakeExceptionsCommandError = async (output, context) => {
+const de_ListDataLakesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1638,15 +1525,21 @@ const de_ListDatalakeExceptionsCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1666,7 +1559,7 @@ export const de_ListLogSourcesCommand = async (output, context) => {
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
         nextToken: __expectString,
-        regionSourceTypesAccountsList: _json,
+        sources: _json,
     });
     Object.assign(contents, doc);
     return contents;
@@ -1681,18 +1574,21 @@ const de_ListLogSourcesCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1712,7 +1608,7 @@ export const de_ListSubscribersCommand = async (output, context) => {
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
         nextToken: __expectString,
-        subscribers: (_) => de_SubscriberList(_, context),
+        subscribers: (_) => de_SubscriberResourceList(_, context),
     });
     Object.assign(contents, doc);
     return contents;
@@ -1727,21 +1623,21 @@ const de_ListSubscribersCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "InvalidInputException":
-        case "com.amazonaws.securitylake#InvalidInputException":
-            throw await de_InvalidInputExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1751,9 +1647,9 @@ const de_ListSubscribersCommandError = async (output, context) => {
             });
     }
 };
-export const de_UpdateDatalakeCommand = async (output, context) => {
+export const de_RegisterDataLakeDelegatedAdministratorCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateDatalakeCommandError(output, context);
+        return de_RegisterDataLakeDelegatedAdministratorCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1761,7 +1657,7 @@ export const de_UpdateDatalakeCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_UpdateDatalakeCommandError = async (output, context) => {
+const de_RegisterDataLakeDelegatedAdministratorCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1771,18 +1667,21 @@ const de_UpdateDatalakeCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "EventBridgeException":
-        case "com.amazonaws.securitylake#EventBridgeException":
-            throw await de_EventBridgeExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1792,17 +1691,21 @@ const de_UpdateDatalakeCommandError = async (output, context) => {
             });
     }
 };
-export const de_UpdateDatalakeExceptionsExpiryCommand = async (output, context) => {
+export const de_UpdateDataLakeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateDatalakeExceptionsExpiryCommandError(output, context);
+        return de_UpdateDataLakeCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    await collectBody(output.body, context);
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        dataLakes: _json,
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateDatalakeExceptionsExpiryCommandError = async (output, context) => {
+const de_UpdateDataLakeCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1812,15 +1715,21 @@ const de_UpdateDatalakeExceptionsExpiryCommandError = async (output, context) =>
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1830,9 +1739,9 @@ const de_UpdateDatalakeExceptionsExpiryCommandError = async (output, context) =>
             });
     }
 };
-export const de_UpdateDatalakeExceptionsSubscriptionCommand = async (output, context) => {
+export const de_UpdateDataLakeExceptionSubscriptionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateDatalakeExceptionsSubscriptionCommandError(output, context);
+        return de_UpdateDataLakeExceptionSubscriptionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1840,7 +1749,7 @@ export const de_UpdateDatalakeExceptionsSubscriptionCommand = async (output, con
     await collectBody(output.body, context);
     return contents;
 };
-const de_UpdateDatalakeExceptionsSubscriptionCommandError = async (output, context) => {
+const de_UpdateDataLakeExceptionSubscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1850,15 +1759,21 @@ const de_UpdateDatalakeExceptionsSubscriptionCommandError = async (output, conte
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1892,24 +1807,21 @@ const de_UpdateSubscriberCommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
-        case "ConcurrentModificationException":
-        case "com.amazonaws.securitylake#ConcurrentModificationException":
-            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
-        case "ConflictSubscriptionException":
-        case "com.amazonaws.securitylake#ConflictSubscriptionException":
-            throw await de_ConflictSubscriptionExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "InvalidInputException":
-        case "com.amazonaws.securitylake#InvalidInputException":
-            throw await de_InvalidInputExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.securitylake#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1919,21 +1831,21 @@ const de_UpdateSubscriberCommandError = async (output, context) => {
             });
     }
 };
-export const de_UpdateSubscriptionNotificationConfigurationCommand = async (output, context) => {
+export const de_UpdateSubscriberNotificationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateSubscriptionNotificationConfigurationCommandError(output, context);
+        return de_UpdateSubscriberNotificationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        queueArn: __expectString,
+        subscriberEndpoint: __expectString,
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateSubscriptionNotificationConfigurationCommandError = async (output, context) => {
+const de_UpdateSubscriberNotificationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1943,24 +1855,21 @@ const de_UpdateSubscriptionNotificationConfigurationCommandError = async (output
         case "AccessDeniedException":
         case "com.amazonaws.securitylake#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "AccountNotFoundException":
-        case "com.amazonaws.securitylake#AccountNotFoundException":
-            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
-        case "ConcurrentModificationException":
-        case "com.amazonaws.securitylake#ConcurrentModificationException":
-            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.securitylake#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.securitylake#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.securitylake#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
-        case "InvalidInputException":
-        case "com.amazonaws.securitylake#InvalidInputException":
-            throw await de_InvalidInputExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.securitylake#ResourceNotFoundException":
             throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.securitylake#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.securitylake#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -1985,40 +1894,14 @@ const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const de_AccountNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = map({});
-    const data = parsedOutput.body;
-    const doc = take(data, {
-        message: __expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccountNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return __decorateServiceException(exception, parsedOutput.body);
-};
-const de_BucketNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = map({});
-    const data = parsedOutput.body;
-    const doc = take(data, {
-        message: __expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new BucketNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return __decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConcurrentModificationExceptionRes = async (parsedOutput, context) => {
+const de_BadRequestExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     const doc = take(data, {
         message: __expectString,
     });
     Object.assign(contents, doc);
-    const exception = new ConcurrentModificationException({
+    const exception = new BadRequestException({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents,
     });
@@ -2029,7 +1912,7 @@ const de_ConflictExceptionRes = async (parsedOutput, context) => {
     const data = parsedOutput.body;
     const doc = take(data, {
         message: __expectString,
-        resourceId: __expectString,
+        resourceName: __expectString,
         resourceType: __expectString,
     });
     Object.assign(contents, doc);
@@ -2039,71 +1922,14 @@ const de_ConflictExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const de_ConflictSourceNamesExceptionRes = async (parsedOutput, context) => {
-    const contents = map({});
-    const data = parsedOutput.body;
-    const doc = take(data, {
-        message: __expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictSourceNamesException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return __decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConflictSubscriptionExceptionRes = async (parsedOutput, context) => {
-    const contents = map({});
-    const data = parsedOutput.body;
-    const doc = take(data, {
-        message: __expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictSubscriptionException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return __decorateServiceException(exception, parsedOutput.body);
-};
-const de_EventBridgeExceptionRes = async (parsedOutput, context) => {
-    const contents = map({});
-    const data = parsedOutput.body;
-    const doc = take(data, {
-        message: __expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new EventBridgeException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return __decorateServiceException(exception, parsedOutput.body);
-};
 const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const contents = map({
-        retryAfterSeconds: [
-            () => void 0 !== parsedOutput.headers["retry-after"],
-            () => __strictParseInt32(parsedOutput.headers["retry-after"]),
-        ],
-    });
-    const data = parsedOutput.body;
-    const doc = take(data, {
-        message: __expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return __decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidInputExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     const doc = take(data, {
         message: __expectString,
     });
     Object.assign(contents, doc);
-    const exception = new InvalidInputException({
+    const exception = new InternalServerException({
         $metadata: deserializeMetadata(parsedOutput),
         ...contents,
     });
@@ -2114,7 +1940,7 @@ const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
     const data = parsedOutput.body;
     const doc = take(data, {
         message: __expectString,
-        resourceId: __expectString,
+        resourceName: __expectString,
         resourceType: __expectString,
     });
     Object.assign(contents, doc);
@@ -2124,36 +1950,6 @@ const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const de_S3ExceptionRes = async (parsedOutput, context) => {
-    const contents = map({});
-    const data = parsedOutput.body;
-    const doc = take(data, {
-        message: __expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new S3Exception({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return __decorateServiceException(exception, parsedOutput.body);
-};
-const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = map({});
-    const data = parsedOutput.body;
-    const doc = take(data, {
-        message: __expectString,
-        quotaCode: __expectString,
-        resourceId: __expectString,
-        resourceType: __expectString,
-        serviceCode: __expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ServiceQuotaExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return __decorateServiceException(exception, parsedOutput.body);
-};
 const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
     const contents = map({
         retryAfterSeconds: [
@@ -2174,79 +1970,49 @@ const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const contents = map({});
-    const data = parsedOutput.body;
-    const doc = take(data, {
-        fieldList: _json,
-        message: __expectString,
-        reason: __expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return __decorateServiceException(exception, parsedOutput.body);
-};
-const de_Failures = (output, context) => {
+const de_DataLakeException = (output, context) => {
     return take(output, {
-        exceptionMessage: __expectString,
+        exception: __expectString,
+        region: __expectString,
         remediation: __expectString,
         timestamp: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
     });
 };
-const de_Failureslist = (output, context) => {
+const de_DataLakeExceptionList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
-        return de_Failures(entry, context);
-    });
-    return retVal;
-};
-const de_FailuresResponse = (output, context) => {
-    return take(output, {
-        failures: (_) => de_Failureslist(_, context),
-        region: __expectString,
-    });
-};
-const de_FailuresResponseList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_FailuresResponse(entry, context);
-    });
-    return retVal;
-};
-const de_SubscriberList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_SubscriberResource(entry, context);
+        return de_DataLakeException(entry, context);
     });
     return retVal;
 };
 const de_SubscriberResource = (output, context) => {
     return take(output, {
         accessTypes: _json,
-        accountId: __expectString,
         createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
-        externalId: __expectString,
         resourceShareArn: __expectString,
         resourceShareName: __expectString,
         roleArn: __expectString,
         s3BucketArn: __expectString,
-        snsArn: __expectString,
-        sourceTypes: _json,
+        sources: _json,
+        subscriberArn: __expectString,
         subscriberDescription: __expectString,
+        subscriberEndpoint: __expectString,
+        subscriberId: __expectString,
+        subscriberIdentity: _json,
         subscriberName: __expectString,
-        subscriptionEndpoint: __expectString,
-        subscriptionId: __expectString,
-        subscriptionProtocol: __expectString,
-        subscriptionStatus: __expectString,
+        subscriberStatus: __expectString,
         updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
     });
 };
+const de_SubscriberResourceList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_SubscriberResource(entry, context);
+    });
+    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"],