@aws-sdk/client-securitylake 3.341.0 → 3.342.0

package/dist-es/SecurityLake.js

@@ -1,66 +1,62 @@
 import { createAggregatedClient } from "@aws-sdk/smithy-client";
 import { CreateAwsLogSourceCommand, } from "./commands/CreateAwsLogSourceCommand";
 import { CreateCustomLogSourceCommand, } from "./commands/CreateCustomLogSourceCommand";
-import { CreateDatalakeAutoEnableCommand, } from "./commands/CreateDatalakeAutoEnableCommand";
-import { CreateDatalakeCommand, } from "./commands/CreateDatalakeCommand";
-import { CreateDatalakeDelegatedAdminCommand, } from "./commands/CreateDatalakeDelegatedAdminCommand";
-import { CreateDatalakeExceptionsSubscriptionCommand, } from "./commands/CreateDatalakeExceptionsSubscriptionCommand";
+import { CreateDataLakeCommand, } from "./commands/CreateDataLakeCommand";
+import { CreateDataLakeExceptionSubscriptionCommand, } from "./commands/CreateDataLakeExceptionSubscriptionCommand";
+import { CreateDataLakeOrganizationConfigurationCommand, } from "./commands/CreateDataLakeOrganizationConfigurationCommand";
 import { CreateSubscriberCommand, } from "./commands/CreateSubscriberCommand";
-import { CreateSubscriptionNotificationConfigurationCommand, } from "./commands/CreateSubscriptionNotificationConfigurationCommand";
+import { CreateSubscriberNotificationCommand, } from "./commands/CreateSubscriberNotificationCommand";
 import { DeleteAwsLogSourceCommand, } from "./commands/DeleteAwsLogSourceCommand";
 import { DeleteCustomLogSourceCommand, } from "./commands/DeleteCustomLogSourceCommand";
-import { DeleteDatalakeAutoEnableCommand, } from "./commands/DeleteDatalakeAutoEnableCommand";
-import { DeleteDatalakeCommand, } from "./commands/DeleteDatalakeCommand";
-import { DeleteDatalakeDelegatedAdminCommand, } from "./commands/DeleteDatalakeDelegatedAdminCommand";
-import { DeleteDatalakeExceptionsSubscriptionCommand, } from "./commands/DeleteDatalakeExceptionsSubscriptionCommand";
+import { DeleteDataLakeCommand, } from "./commands/DeleteDataLakeCommand";
+import { DeleteDataLakeExceptionSubscriptionCommand, } from "./commands/DeleteDataLakeExceptionSubscriptionCommand";
+import { DeleteDataLakeOrganizationConfigurationCommand, } from "./commands/DeleteDataLakeOrganizationConfigurationCommand";
 import { DeleteSubscriberCommand, } from "./commands/DeleteSubscriberCommand";
-import { DeleteSubscriptionNotificationConfigurationCommand, } from "./commands/DeleteSubscriptionNotificationConfigurationCommand";
-import { GetDatalakeAutoEnableCommand, } from "./commands/GetDatalakeAutoEnableCommand";
-import { GetDatalakeCommand } from "./commands/GetDatalakeCommand";
-import { GetDatalakeExceptionsExpiryCommand, } from "./commands/GetDatalakeExceptionsExpiryCommand";
-import { GetDatalakeExceptionsSubscriptionCommand, } from "./commands/GetDatalakeExceptionsSubscriptionCommand";
-import { GetDatalakeStatusCommand, } from "./commands/GetDatalakeStatusCommand";
+import { DeleteSubscriberNotificationCommand, } from "./commands/DeleteSubscriberNotificationCommand";
+import { DeregisterDataLakeDelegatedAdministratorCommand, } from "./commands/DeregisterDataLakeDelegatedAdministratorCommand";
+import { GetDataLakeExceptionSubscriptionCommand, } from "./commands/GetDataLakeExceptionSubscriptionCommand";
+import { GetDataLakeOrganizationConfigurationCommand, } from "./commands/GetDataLakeOrganizationConfigurationCommand";
+import { GetDataLakeSourcesCommand, } from "./commands/GetDataLakeSourcesCommand";
 import { GetSubscriberCommand, } from "./commands/GetSubscriberCommand";
-import { ListDatalakeExceptionsCommand, } from "./commands/ListDatalakeExceptionsCommand";
+import { ListDataLakeExceptionsCommand, } from "./commands/ListDataLakeExceptionsCommand";
+import { ListDataLakesCommand, } from "./commands/ListDataLakesCommand";
 import { ListLogSourcesCommand, } from "./commands/ListLogSourcesCommand";
 import { ListSubscribersCommand, } from "./commands/ListSubscribersCommand";
-import { UpdateDatalakeCommand, } from "./commands/UpdateDatalakeCommand";
-import { UpdateDatalakeExceptionsExpiryCommand, } from "./commands/UpdateDatalakeExceptionsExpiryCommand";
-import { UpdateDatalakeExceptionsSubscriptionCommand, } from "./commands/UpdateDatalakeExceptionsSubscriptionCommand";
+import { RegisterDataLakeDelegatedAdministratorCommand, } from "./commands/RegisterDataLakeDelegatedAdministratorCommand";
+import { UpdateDataLakeCommand, } from "./commands/UpdateDataLakeCommand";
+import { UpdateDataLakeExceptionSubscriptionCommand, } from "./commands/UpdateDataLakeExceptionSubscriptionCommand";
 import { UpdateSubscriberCommand, } from "./commands/UpdateSubscriberCommand";
-import { UpdateSubscriptionNotificationConfigurationCommand, } from "./commands/UpdateSubscriptionNotificationConfigurationCommand";
+import { UpdateSubscriberNotificationCommand, } from "./commands/UpdateSubscriberNotificationCommand";
 import { SecurityLakeClient } from "./SecurityLakeClient";
 const commands = {
     CreateAwsLogSourceCommand,
     CreateCustomLogSourceCommand,
-    CreateDatalakeCommand,
-    CreateDatalakeAutoEnableCommand,
-    CreateDatalakeDelegatedAdminCommand,
-    CreateDatalakeExceptionsSubscriptionCommand,
+    CreateDataLakeCommand,
+    CreateDataLakeExceptionSubscriptionCommand,
+    CreateDataLakeOrganizationConfigurationCommand,
     CreateSubscriberCommand,
-    CreateSubscriptionNotificationConfigurationCommand,
+    CreateSubscriberNotificationCommand,
     DeleteAwsLogSourceCommand,
     DeleteCustomLogSourceCommand,
-    DeleteDatalakeCommand,
-    DeleteDatalakeAutoEnableCommand,
-    DeleteDatalakeDelegatedAdminCommand,
-    DeleteDatalakeExceptionsSubscriptionCommand,
+    DeleteDataLakeCommand,
+    DeleteDataLakeExceptionSubscriptionCommand,
+    DeleteDataLakeOrganizationConfigurationCommand,
     DeleteSubscriberCommand,
-    DeleteSubscriptionNotificationConfigurationCommand,
-    GetDatalakeCommand,
-    GetDatalakeAutoEnableCommand,
-    GetDatalakeExceptionsExpiryCommand,
-    GetDatalakeExceptionsSubscriptionCommand,
-    GetDatalakeStatusCommand,
+    DeleteSubscriberNotificationCommand,
+    DeregisterDataLakeDelegatedAdministratorCommand,
+    GetDataLakeExceptionSubscriptionCommand,
+    GetDataLakeOrganizationConfigurationCommand,
+    GetDataLakeSourcesCommand,
     GetSubscriberCommand,
-    ListDatalakeExceptionsCommand,
+    ListDataLakeExceptionsCommand,
+    ListDataLakesCommand,
     ListLogSourcesCommand,
     ListSubscribersCommand,
-    UpdateDatalakeCommand,
-    UpdateDatalakeExceptionsExpiryCommand,
-    UpdateDatalakeExceptionsSubscriptionCommand,
+    RegisterDataLakeDelegatedAdministratorCommand,
+    UpdateDataLakeCommand,
+    UpdateDataLakeExceptionSubscriptionCommand,
     UpdateSubscriberCommand,
-    UpdateSubscriptionNotificationConfigurationCommand,
+    UpdateSubscriberNotificationCommand,
 };
 export class SecurityLake extends SecurityLakeClient {
 }

package/dist-es/commands/{UpdateDatalakeCommand.js → CreateDataLakeCommand.js}

@@ -1,9 +1,9 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { de_UpdateDatalakeCommand, se_UpdateDatalakeCommand } from "../protocols/Aws_restJson1";
+import { de_CreateDataLakeCommand, se_CreateDataLakeCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class UpdateDatalakeCommand extends $Command {
+export class CreateDataLakeCommand extends $Command {
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -18,11 +18,11 @@ export class UpdateDatalakeCommand extends $Command {
     }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateDatalakeCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateDataLakeCommand.getEndpointParameterInstructions()));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;
         const clientName = "SecurityLakeClient";
-        const commandName = "UpdateDatalakeCommand";
+        const commandName = "CreateDataLakeCommand";
         const handlerExecutionContext = {
             logger,
             clientName,
@@ -34,9 +34,9 @@ export class UpdateDatalakeCommand extends $Command {
         return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
     }
     serialize(input, context) {
-        return se_UpdateDatalakeCommand(input, context);
+        return se_CreateDataLakeCommand(input, context);
     }
     deserialize(output, context) {
-        return de_UpdateDatalakeCommand(output, context);
+        return de_CreateDataLakeCommand(output, context);
     }
 }

package/dist-es/commands/{UpdateDatalakeExceptionsSubscriptionCommand.js → CreateDataLakeExceptionSubscriptionCommand.js}

@@ -1,9 +1,9 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { de_UpdateDatalakeExceptionsSubscriptionCommand, se_UpdateDatalakeExceptionsSubscriptionCommand, } from "../protocols/Aws_restJson1";
+import { de_CreateDataLakeExceptionSubscriptionCommand, se_CreateDataLakeExceptionSubscriptionCommand, } from "../protocols/Aws_restJson1";
 export { $Command };
-export class UpdateDatalakeExceptionsSubscriptionCommand extends $Command {
+export class CreateDataLakeExceptionSubscriptionCommand extends $Command {
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -18,11 +18,11 @@ export class UpdateDatalakeExceptionsSubscriptionCommand extends $Command {
     }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateDatalakeExceptionsSubscriptionCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateDataLakeExceptionSubscriptionCommand.getEndpointParameterInstructions()));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;
         const clientName = "SecurityLakeClient";
-        const commandName = "UpdateDatalakeExceptionsSubscriptionCommand";
+        const commandName = "CreateDataLakeExceptionSubscriptionCommand";
         const handlerExecutionContext = {
             logger,
             clientName,
@@ -34,9 +34,9 @@ export class UpdateDatalakeExceptionsSubscriptionCommand extends $Command {
         return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
     }
     serialize(input, context) {
-        return se_UpdateDatalakeExceptionsSubscriptionCommand(input, context);
+        return se_CreateDataLakeExceptionSubscriptionCommand(input, context);
     }
     deserialize(output, context) {
-        return de_UpdateDatalakeExceptionsSubscriptionCommand(output, context);
+        return de_CreateDataLakeExceptionSubscriptionCommand(output, context);
     }
 }

package/dist-es/commands/CreateDataLakeOrganizationConfigurationCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_CreateDataLakeOrganizationConfigurationCommand, se_CreateDataLakeOrganizationConfigurationCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateDataLakeOrganizationConfigurationCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateDataLakeOrganizationConfigurationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "CreateDataLakeOrganizationConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateDataLakeOrganizationConfigurationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateDataLakeOrganizationConfigurationCommand(output, context);
+    }
+}

package/dist-es/commands/{DeleteDatalakeDelegatedAdminCommand.js → CreateSubscriberNotificationCommand.js}

@@ -1,9 +1,9 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { de_DeleteDatalakeDelegatedAdminCommand, se_DeleteDatalakeDelegatedAdminCommand, } from "../protocols/Aws_restJson1";
+import { de_CreateSubscriberNotificationCommand, se_CreateSubscriberNotificationCommand, } from "../protocols/Aws_restJson1";
 export { $Command };
-export class DeleteDatalakeDelegatedAdminCommand extends $Command {
+export class CreateSubscriberNotificationCommand extends $Command {
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -18,11 +18,11 @@ export class DeleteDatalakeDelegatedAdminCommand extends $Command {
     }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteDatalakeDelegatedAdminCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateSubscriberNotificationCommand.getEndpointParameterInstructions()));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;
         const clientName = "SecurityLakeClient";
-        const commandName = "DeleteDatalakeDelegatedAdminCommand";
+        const commandName = "CreateSubscriberNotificationCommand";
         const handlerExecutionContext = {
             logger,
             clientName,
@@ -34,9 +34,9 @@ export class DeleteDatalakeDelegatedAdminCommand extends $Command {
         return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
     }
     serialize(input, context) {
-        return se_DeleteDatalakeDelegatedAdminCommand(input, context);
+        return se_CreateSubscriberNotificationCommand(input, context);
     }
     deserialize(output, context) {
-        return de_DeleteDatalakeDelegatedAdminCommand(output, context);
+        return de_CreateSubscriberNotificationCommand(output, context);
     }
 }

package/dist-es/commands/{CreateDatalakeCommand.js → DeleteDataLakeCommand.js}

@@ -1,9 +1,9 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { de_CreateDatalakeCommand, se_CreateDatalakeCommand } from "../protocols/Aws_restJson1";
+import { de_DeleteDataLakeCommand, se_DeleteDataLakeCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreateDatalakeCommand extends $Command {
+export class DeleteDataLakeCommand extends $Command {
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -18,11 +18,11 @@ export class CreateDatalakeCommand extends $Command {
     }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, CreateDatalakeCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteDataLakeCommand.getEndpointParameterInstructions()));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;
         const clientName = "SecurityLakeClient";
-        const commandName = "CreateDatalakeCommand";
+        const commandName = "DeleteDataLakeCommand";
         const handlerExecutionContext = {
             logger,
             clientName,
@@ -34,9 +34,9 @@ export class CreateDatalakeCommand extends $Command {
         return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
     }
     serialize(input, context) {
-        return se_CreateDatalakeCommand(input, context);
+        return se_DeleteDataLakeCommand(input, context);
     }
     deserialize(output, context) {
-        return de_CreateDatalakeCommand(output, context);
+        return de_DeleteDataLakeCommand(output, context);
     }
 }

package/dist-es/commands/{CreateDatalakeExceptionsSubscriptionCommand.js → DeleteDataLakeExceptionSubscriptionCommand.js}

@@ -1,9 +1,9 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { de_CreateDatalakeExceptionsSubscriptionCommand, se_CreateDatalakeExceptionsSubscriptionCommand, } from "../protocols/Aws_restJson1";
+import { de_DeleteDataLakeExceptionSubscriptionCommand, se_DeleteDataLakeExceptionSubscriptionCommand, } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreateDatalakeExceptionsSubscriptionCommand extends $Command {
+export class DeleteDataLakeExceptionSubscriptionCommand extends $Command {
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -18,11 +18,11 @@ export class CreateDatalakeExceptionsSubscriptionCommand extends $Command {
     }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, CreateDatalakeExceptionsSubscriptionCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteDataLakeExceptionSubscriptionCommand.getEndpointParameterInstructions()));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;
         const clientName = "SecurityLakeClient";
-        const commandName = "CreateDatalakeExceptionsSubscriptionCommand";
+        const commandName = "DeleteDataLakeExceptionSubscriptionCommand";
         const handlerExecutionContext = {
             logger,
             clientName,
@@ -34,9 +34,9 @@ export class CreateDatalakeExceptionsSubscriptionCommand extends $Command {
         return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
     }
     serialize(input, context) {
-        return se_CreateDatalakeExceptionsSubscriptionCommand(input, context);
+        return se_DeleteDataLakeExceptionSubscriptionCommand(input, context);
     }
     deserialize(output, context) {
-        return de_CreateDatalakeExceptionsSubscriptionCommand(output, context);
+        return de_DeleteDataLakeExceptionSubscriptionCommand(output, context);
     }
 }

package/dist-es/commands/DeleteDataLakeOrganizationConfigurationCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_DeleteDataLakeOrganizationConfigurationCommand, se_DeleteDataLakeOrganizationConfigurationCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteDataLakeOrganizationConfigurationCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteDataLakeOrganizationConfigurationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "DeleteDataLakeOrganizationConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteDataLakeOrganizationConfigurationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteDataLakeOrganizationConfigurationCommand(output, context);
+    }
+}

package/dist-es/commands/{CreateDatalakeDelegatedAdminCommand.js → DeleteSubscriberNotificationCommand.js}

@@ -1,9 +1,9 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { de_CreateDatalakeDelegatedAdminCommand, se_CreateDatalakeDelegatedAdminCommand, } from "../protocols/Aws_restJson1";
+import { de_DeleteSubscriberNotificationCommand, se_DeleteSubscriberNotificationCommand, } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreateDatalakeDelegatedAdminCommand extends $Command {
+export class DeleteSubscriberNotificationCommand extends $Command {
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -18,11 +18,11 @@ export class CreateDatalakeDelegatedAdminCommand extends $Command {
     }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, CreateDatalakeDelegatedAdminCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteSubscriberNotificationCommand.getEndpointParameterInstructions()));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;
         const clientName = "SecurityLakeClient";
-        const commandName = "CreateDatalakeDelegatedAdminCommand";
+        const commandName = "DeleteSubscriberNotificationCommand";
         const handlerExecutionContext = {
             logger,
             clientName,
@@ -34,9 +34,9 @@ export class CreateDatalakeDelegatedAdminCommand extends $Command {
         return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
     }
     serialize(input, context) {
-        return se_CreateDatalakeDelegatedAdminCommand(input, context);
+        return se_DeleteSubscriberNotificationCommand(input, context);
     }
     deserialize(output, context) {
-        return de_CreateDatalakeDelegatedAdminCommand(output, context);
+        return de_DeleteSubscriberNotificationCommand(output, context);
     }
 }

package/dist-es/commands/DeregisterDataLakeDelegatedAdministratorCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_DeregisterDataLakeDelegatedAdministratorCommand, se_DeregisterDataLakeDelegatedAdministratorCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeregisterDataLakeDelegatedAdministratorCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeregisterDataLakeDelegatedAdministratorCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "DeregisterDataLakeDelegatedAdministratorCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeregisterDataLakeDelegatedAdministratorCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeregisterDataLakeDelegatedAdministratorCommand(output, context);
+    }
+}

package/dist-es/commands/{GetDatalakeExceptionsSubscriptionCommand.js → GetDataLakeExceptionSubscriptionCommand.js}

@@ -1,9 +1,9 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { de_GetDatalakeExceptionsSubscriptionCommand, se_GetDatalakeExceptionsSubscriptionCommand, } from "../protocols/Aws_restJson1";
+import { de_GetDataLakeExceptionSubscriptionCommand, se_GetDataLakeExceptionSubscriptionCommand, } from "../protocols/Aws_restJson1";
 export { $Command };
-export class GetDatalakeExceptionsSubscriptionCommand extends $Command {
+export class GetDataLakeExceptionSubscriptionCommand extends $Command {
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -18,11 +18,11 @@ export class GetDatalakeExceptionsSubscriptionCommand extends $Command {
     }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, GetDatalakeExceptionsSubscriptionCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetDataLakeExceptionSubscriptionCommand.getEndpointParameterInstructions()));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;
         const clientName = "SecurityLakeClient";
-        const commandName = "GetDatalakeExceptionsSubscriptionCommand";
+        const commandName = "GetDataLakeExceptionSubscriptionCommand";
         const handlerExecutionContext = {
             logger,
             clientName,
@@ -34,9 +34,9 @@ export class GetDatalakeExceptionsSubscriptionCommand extends $Command {
         return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
     }
     serialize(input, context) {
-        return se_GetDatalakeExceptionsSubscriptionCommand(input, context);
+        return se_GetDataLakeExceptionSubscriptionCommand(input, context);
     }
     deserialize(output, context) {
-        return de_GetDatalakeExceptionsSubscriptionCommand(output, context);
+        return de_GetDataLakeExceptionSubscriptionCommand(output, context);
     }
 }

package/dist-es/commands/{DeleteDatalakeExceptionsSubscriptionCommand.js → GetDataLakeOrganizationConfigurationCommand.js}

@@ -1,9 +1,9 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { de_DeleteDatalakeExceptionsSubscriptionCommand, se_DeleteDatalakeExceptionsSubscriptionCommand, } from "../protocols/Aws_restJson1";
+import { de_GetDataLakeOrganizationConfigurationCommand, se_GetDataLakeOrganizationConfigurationCommand, } from "../protocols/Aws_restJson1";
 export { $Command };
-export class DeleteDatalakeExceptionsSubscriptionCommand extends $Command {
+export class GetDataLakeOrganizationConfigurationCommand extends $Command {
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -18,11 +18,11 @@ export class DeleteDatalakeExceptionsSubscriptionCommand extends $Command {
     }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteDatalakeExceptionsSubscriptionCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetDataLakeOrganizationConfigurationCommand.getEndpointParameterInstructions()));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;
         const clientName = "SecurityLakeClient";
-        const commandName = "DeleteDatalakeExceptionsSubscriptionCommand";
+        const commandName = "GetDataLakeOrganizationConfigurationCommand";
         const handlerExecutionContext = {
             logger,
             clientName,
@@ -34,9 +34,9 @@ export class DeleteDatalakeExceptionsSubscriptionCommand extends $Command {
         return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
     }
     serialize(input, context) {
-        return se_DeleteDatalakeExceptionsSubscriptionCommand(input, context);
+        return se_GetDataLakeOrganizationConfigurationCommand(input, context);
     }
     deserialize(output, context) {
-        return de_DeleteDatalakeExceptionsSubscriptionCommand(output, context);
+        return de_GetDataLakeOrganizationConfigurationCommand(output, context);
     }
 }

package/dist-es/commands/{GetDatalakeStatusCommand.js → GetDataLakeSourcesCommand.js}

@@ -1,9 +1,9 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { de_GetDatalakeStatusCommand, se_GetDatalakeStatusCommand } from "../protocols/Aws_restJson1";
+import { de_GetDataLakeSourcesCommand, se_GetDataLakeSourcesCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class GetDatalakeStatusCommand extends $Command {
+export class GetDataLakeSourcesCommand extends $Command {
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -18,11 +18,11 @@ export class GetDatalakeStatusCommand extends $Command {
     }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, GetDatalakeStatusCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetDataLakeSourcesCommand.getEndpointParameterInstructions()));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;
         const clientName = "SecurityLakeClient";
-        const commandName = "GetDatalakeStatusCommand";
+        const commandName = "GetDataLakeSourcesCommand";
         const handlerExecutionContext = {
             logger,
             clientName,
@@ -34,9 +34,9 @@ export class GetDatalakeStatusCommand extends $Command {
         return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
     }
     serialize(input, context) {
-        return se_GetDatalakeStatusCommand(input, context);
+        return se_GetDataLakeSourcesCommand(input, context);
     }
     deserialize(output, context) {
-        return de_GetDatalakeStatusCommand(output, context);
+        return de_GetDataLakeSourcesCommand(output, context);
     }
 }

package/dist-es/commands/{ListDatalakeExceptionsCommand.js → ListDataLakeExceptionsCommand.js}

@@ -1,9 +1,9 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { de_ListDatalakeExceptionsCommand, se_ListDatalakeExceptionsCommand } from "../protocols/Aws_restJson1";
+import { de_ListDataLakeExceptionsCommand, se_ListDataLakeExceptionsCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class ListDatalakeExceptionsCommand extends $Command {
+export class ListDataLakeExceptionsCommand extends $Command {
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -18,11 +18,11 @@ export class ListDatalakeExceptionsCommand extends $Command {
     }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, ListDatalakeExceptionsCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListDataLakeExceptionsCommand.getEndpointParameterInstructions()));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;
         const clientName = "SecurityLakeClient";
-        const commandName = "ListDatalakeExceptionsCommand";
+        const commandName = "ListDataLakeExceptionsCommand";
         const handlerExecutionContext = {
             logger,
             clientName,
@@ -34,9 +34,9 @@ export class ListDatalakeExceptionsCommand extends $Command {
         return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
     }
     serialize(input, context) {
-        return se_ListDatalakeExceptionsCommand(input, context);
+        return se_ListDataLakeExceptionsCommand(input, context);
     }
     deserialize(output, context) {
-        return de_ListDatalakeExceptionsCommand(output, context);
+        return de_ListDataLakeExceptionsCommand(output, context);
     }
 }