@aws-sdk/client-securitylake 3.220.0

package/dist-es/commands/CreateCustomLogSourceCommand.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 { CreateCustomLogSourceRequestFilterSensitiveLog, CreateCustomLogSourceResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateCustomLogSourceCommand, serializeAws_restJson1CreateCustomLogSourceCommand, } from "../protocols/Aws_restJson1";
+export class CreateCustomLogSourceCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateCustomLogSourceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "CreateCustomLogSourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateCustomLogSourceRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateCustomLogSourceResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1CreateCustomLogSourceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1CreateCustomLogSourceCommand(output, context);
+    }
+}

package/dist-es/commands/CreateDatalakeAutoEnableCommand.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 { CreateDatalakeAutoEnableRequestFilterSensitiveLog, CreateDatalakeAutoEnableResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateDatalakeAutoEnableCommand, serializeAws_restJson1CreateDatalakeAutoEnableCommand, } from "../protocols/Aws_restJson1";
+export class CreateDatalakeAutoEnableCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateDatalakeAutoEnableCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "CreateDatalakeAutoEnableCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateDatalakeAutoEnableRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateDatalakeAutoEnableResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1CreateDatalakeAutoEnableCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1CreateDatalakeAutoEnableCommand(output, context);
+    }
+}

package/dist-es/commands/CreateDatalakeCommand.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 { CreateDatalakeRequestFilterSensitiveLog, CreateDatalakeResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateDatalakeCommand, serializeAws_restJson1CreateDatalakeCommand, } from "../protocols/Aws_restJson1";
+export class CreateDatalakeCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateDatalakeCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "CreateDatalakeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateDatalakeRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateDatalakeResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1CreateDatalakeCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1CreateDatalakeCommand(output, context);
+    }
+}

package/dist-es/commands/CreateDatalakeDelegatedAdminCommand.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 { CreateDatalakeDelegatedAdminRequestFilterSensitiveLog, CreateDatalakeDelegatedAdminResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateDatalakeDelegatedAdminCommand, serializeAws_restJson1CreateDatalakeDelegatedAdminCommand, } from "../protocols/Aws_restJson1";
+export class CreateDatalakeDelegatedAdminCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateDatalakeDelegatedAdminCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "CreateDatalakeDelegatedAdminCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateDatalakeDelegatedAdminRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateDatalakeDelegatedAdminResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1CreateDatalakeDelegatedAdminCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1CreateDatalakeDelegatedAdminCommand(output, context);
+    }
+}

package/dist-es/commands/CreateDatalakeExceptionsSubscriptionCommand.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 { CreateDatalakeExceptionsSubscriptionRequestFilterSensitiveLog, CreateDatalakeExceptionsSubscriptionResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand, serializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand, } from "../protocols/Aws_restJson1";
+export class CreateDatalakeExceptionsSubscriptionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateDatalakeExceptionsSubscriptionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "CreateDatalakeExceptionsSubscriptionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateDatalakeExceptionsSubscriptionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateDatalakeExceptionsSubscriptionResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1CreateDatalakeExceptionsSubscriptionCommand(output, context);
+    }
+}

package/dist-es/commands/CreateSubscriberCommand.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 { CreateSubscriberRequestFilterSensitiveLog, CreateSubscriberResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateSubscriberCommand, serializeAws_restJson1CreateSubscriberCommand, } from "../protocols/Aws_restJson1";
+export class CreateSubscriberCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateSubscriberCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "CreateSubscriberCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateSubscriberRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateSubscriberResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1CreateSubscriberCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1CreateSubscriberCommand(output, context);
+    }
+}

package/dist-es/commands/CreateSubscriptionNotificationConfigurationCommand.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 { CreateSubscriptionNotificationConfigurationRequestFilterSensitiveLog, CreateSubscriptionNotificationConfigurationResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand, serializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand, } from "../protocols/Aws_restJson1";
+export class CreateSubscriptionNotificationConfigurationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateSubscriptionNotificationConfigurationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "CreateSubscriptionNotificationConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateSubscriptionNotificationConfigurationRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateSubscriptionNotificationConfigurationResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1CreateSubscriptionNotificationConfigurationCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteAwsLogSourceCommand.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 { DeleteAwsLogSourceRequestFilterSensitiveLog, DeleteAwsLogSourceResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteAwsLogSourceCommand, serializeAws_restJson1DeleteAwsLogSourceCommand, } from "../protocols/Aws_restJson1";
+export class DeleteAwsLogSourceCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteAwsLogSourceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "DeleteAwsLogSourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteAwsLogSourceRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteAwsLogSourceResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteAwsLogSourceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteAwsLogSourceCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteCustomLogSourceCommand.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 { DeleteCustomLogSourceRequestFilterSensitiveLog, DeleteCustomLogSourceResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteCustomLogSourceCommand, serializeAws_restJson1DeleteCustomLogSourceCommand, } from "../protocols/Aws_restJson1";
+export class DeleteCustomLogSourceCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteCustomLogSourceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "DeleteCustomLogSourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteCustomLogSourceRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteCustomLogSourceResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteCustomLogSourceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteCustomLogSourceCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteDatalakeAutoEnableCommand.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 { DeleteDatalakeAutoEnableRequestFilterSensitiveLog, DeleteDatalakeAutoEnableResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteDatalakeAutoEnableCommand, serializeAws_restJson1DeleteDatalakeAutoEnableCommand, } from "../protocols/Aws_restJson1";
+export class DeleteDatalakeAutoEnableCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteDatalakeAutoEnableCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "DeleteDatalakeAutoEnableCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteDatalakeAutoEnableRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteDatalakeAutoEnableResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteDatalakeAutoEnableCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteDatalakeAutoEnableCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteDatalakeCommand.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 { DeleteDatalakeRequestFilterSensitiveLog, DeleteDatalakeResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteDatalakeCommand, serializeAws_restJson1DeleteDatalakeCommand, } from "../protocols/Aws_restJson1";
+export class DeleteDatalakeCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteDatalakeCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "DeleteDatalakeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteDatalakeRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteDatalakeResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteDatalakeCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteDatalakeCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteDatalakeDelegatedAdminCommand.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 { DeleteDatalakeDelegatedAdminRequestFilterSensitiveLog, DeleteDatalakeDelegatedAdminResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommand, serializeAws_restJson1DeleteDatalakeDelegatedAdminCommand, } from "../protocols/Aws_restJson1";
+export class DeleteDatalakeDelegatedAdminCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteDatalakeDelegatedAdminCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "DeleteDatalakeDelegatedAdminCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteDatalakeDelegatedAdminRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteDatalakeDelegatedAdminResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteDatalakeDelegatedAdminCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteDatalakeDelegatedAdminCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteDatalakeExceptionsSubscriptionCommand.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 { DeleteDatalakeExceptionsSubscriptionRequestFilterSensitiveLog, DeleteDatalakeExceptionsSubscriptionResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand, serializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand, } from "../protocols/Aws_restJson1";
+export class DeleteDatalakeExceptionsSubscriptionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteDatalakeExceptionsSubscriptionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "DeleteDatalakeExceptionsSubscriptionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteDatalakeExceptionsSubscriptionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteDatalakeExceptionsSubscriptionResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteDatalakeExceptionsSubscriptionCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteSubscriberCommand.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 { DeleteSubscriberRequestFilterSensitiveLog, DeleteSubscriberResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteSubscriberCommand, serializeAws_restJson1DeleteSubscriberCommand, } from "../protocols/Aws_restJson1";
+export class DeleteSubscriberCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteSubscriberCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "DeleteSubscriberCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteSubscriberRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteSubscriberResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteSubscriberCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteSubscriberCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteSubscriptionNotificationConfigurationCommand.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 { DeleteSubscriptionNotificationConfigurationRequestFilterSensitiveLog, DeleteSubscriptionNotificationConfigurationResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand, serializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand, } from "../protocols/Aws_restJson1";
+export class DeleteSubscriptionNotificationConfigurationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteSubscriptionNotificationConfigurationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "DeleteSubscriptionNotificationConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteSubscriptionNotificationConfigurationRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteSubscriptionNotificationConfigurationResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteSubscriptionNotificationConfigurationCommand(output, context);
+    }
+}