@aws-sdk/client-securitylake 3.220.0

package/dist-es/commands/GetDatalakeAutoEnableCommand.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 { GetDatalakeAutoEnableRequestFilterSensitiveLog, GetDatalakeAutoEnableResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetDatalakeAutoEnableCommand, serializeAws_restJson1GetDatalakeAutoEnableCommand, } from "../protocols/Aws_restJson1";
+export class GetDatalakeAutoEnableCommand 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, GetDatalakeAutoEnableCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "GetDatalakeAutoEnableCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetDatalakeAutoEnableRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetDatalakeAutoEnableResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetDatalakeAutoEnableCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetDatalakeAutoEnableCommand(output, context);
+    }
+}

package/dist-es/commands/GetDatalakeCommand.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 { GetDatalakeRequestFilterSensitiveLog, GetDatalakeResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetDatalakeCommand, serializeAws_restJson1GetDatalakeCommand, } from "../protocols/Aws_restJson1";
+export class GetDatalakeCommand 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, GetDatalakeCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "GetDatalakeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetDatalakeRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetDatalakeResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetDatalakeCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetDatalakeCommand(output, context);
+    }
+}

package/dist-es/commands/GetDatalakeExceptionsExpiryCommand.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 { GetDatalakeExceptionsExpiryRequestFilterSensitiveLog, GetDatalakeExceptionsExpiryResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetDatalakeExceptionsExpiryCommand, serializeAws_restJson1GetDatalakeExceptionsExpiryCommand, } from "../protocols/Aws_restJson1";
+export class GetDatalakeExceptionsExpiryCommand 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, GetDatalakeExceptionsExpiryCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "GetDatalakeExceptionsExpiryCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetDatalakeExceptionsExpiryRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetDatalakeExceptionsExpiryResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetDatalakeExceptionsExpiryCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetDatalakeExceptionsExpiryCommand(output, context);
+    }
+}

package/dist-es/commands/GetDatalakeExceptionsSubscriptionCommand.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 { GetDatalakeExceptionsSubscriptionRequestFilterSensitiveLog, GetDatalakeExceptionsSubscriptionResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand, serializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand, } from "../protocols/Aws_restJson1";
+export class GetDatalakeExceptionsSubscriptionCommand 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, GetDatalakeExceptionsSubscriptionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "GetDatalakeExceptionsSubscriptionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetDatalakeExceptionsSubscriptionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetDatalakeExceptionsSubscriptionResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetDatalakeExceptionsSubscriptionCommand(output, context);
+    }
+}

package/dist-es/commands/GetDatalakeStatusCommand.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 { GetDatalakeStatusRequestFilterSensitiveLog, GetDatalakeStatusResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetDatalakeStatusCommand, serializeAws_restJson1GetDatalakeStatusCommand, } from "../protocols/Aws_restJson1";
+export class GetDatalakeStatusCommand 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, GetDatalakeStatusCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "GetDatalakeStatusCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetDatalakeStatusRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetDatalakeStatusResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetDatalakeStatusCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetDatalakeStatusCommand(output, context);
+    }
+}

package/dist-es/commands/GetSubscriberCommand.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 { GetSubscriberRequestFilterSensitiveLog, GetSubscriberResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetSubscriberCommand, serializeAws_restJson1GetSubscriberCommand, } from "../protocols/Aws_restJson1";
+export class GetSubscriberCommand 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, GetSubscriberCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "GetSubscriberCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetSubscriberRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetSubscriberResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetSubscriberCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetSubscriberCommand(output, context);
+    }
+}

package/dist-es/commands/ListDatalakeExceptionsCommand.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 { ListDatalakeExceptionsRequestFilterSensitiveLog, ListDatalakeExceptionsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListDatalakeExceptionsCommand, serializeAws_restJson1ListDatalakeExceptionsCommand, } from "../protocols/Aws_restJson1";
+export class ListDatalakeExceptionsCommand 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, ListDatalakeExceptionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "ListDatalakeExceptionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListDatalakeExceptionsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListDatalakeExceptionsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListDatalakeExceptionsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListDatalakeExceptionsCommand(output, context);
+    }
+}

package/dist-es/commands/ListLogSourcesCommand.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 { ListLogSourcesRequestFilterSensitiveLog, ListLogSourcesResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListLogSourcesCommand, serializeAws_restJson1ListLogSourcesCommand, } from "../protocols/Aws_restJson1";
+export class ListLogSourcesCommand 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, ListLogSourcesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "ListLogSourcesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListLogSourcesRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListLogSourcesResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListLogSourcesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListLogSourcesCommand(output, context);
+    }
+}

package/dist-es/commands/ListSubscribersCommand.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 { ListSubscribersRequestFilterSensitiveLog, ListSubscribersResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListSubscribersCommand, serializeAws_restJson1ListSubscribersCommand, } from "../protocols/Aws_restJson1";
+export class ListSubscribersCommand 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, ListSubscribersCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "ListSubscribersCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListSubscribersRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListSubscribersResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListSubscribersCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListSubscribersCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateDatalakeCommand.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 { UpdateDatalakeRequestFilterSensitiveLog, UpdateDatalakeResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1UpdateDatalakeCommand, serializeAws_restJson1UpdateDatalakeCommand, } from "../protocols/Aws_restJson1";
+export class UpdateDatalakeCommand 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, UpdateDatalakeCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "UpdateDatalakeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UpdateDatalakeRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: UpdateDatalakeResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1UpdateDatalakeCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1UpdateDatalakeCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateDatalakeExceptionsExpiryCommand.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 { UpdateDatalakeExceptionsExpiryRequestFilterSensitiveLog, UpdateDatalakeExceptionsExpiryResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand, serializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand, } from "../protocols/Aws_restJson1";
+export class UpdateDatalakeExceptionsExpiryCommand 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, UpdateDatalakeExceptionsExpiryCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "UpdateDatalakeExceptionsExpiryCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UpdateDatalakeExceptionsExpiryRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: UpdateDatalakeExceptionsExpiryResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1UpdateDatalakeExceptionsExpiryCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateDatalakeExceptionsSubscriptionCommand.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 { UpdateDatalakeExceptionsSubscriptionRequestFilterSensitiveLog, UpdateDatalakeExceptionsSubscriptionResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand, serializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand, } from "../protocols/Aws_restJson1";
+export class UpdateDatalakeExceptionsSubscriptionCommand 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, UpdateDatalakeExceptionsSubscriptionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "UpdateDatalakeExceptionsSubscriptionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UpdateDatalakeExceptionsSubscriptionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: UpdateDatalakeExceptionsSubscriptionResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1UpdateDatalakeExceptionsSubscriptionCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateSubscriberCommand.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 { UpdateSubscriberRequestFilterSensitiveLog, UpdateSubscriberResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1UpdateSubscriberCommand, serializeAws_restJson1UpdateSubscriberCommand, } from "../protocols/Aws_restJson1";
+export class UpdateSubscriberCommand 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, UpdateSubscriberCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "UpdateSubscriberCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UpdateSubscriberRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: UpdateSubscriberResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1UpdateSubscriberCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1UpdateSubscriberCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateSubscriptionNotificationConfigurationCommand.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 { UpdateSubscriptionNotificationConfigurationRequestFilterSensitiveLog, UpdateSubscriptionNotificationConfigurationResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand, serializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand, } from "../protocols/Aws_restJson1";
+export class UpdateSubscriptionNotificationConfigurationCommand 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, UpdateSubscriptionNotificationConfigurationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "UpdateSubscriptionNotificationConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UpdateSubscriptionNotificationConfigurationRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: UpdateSubscriptionNotificationConfigurationResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1UpdateSubscriptionNotificationConfigurationCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -0,0 +1,30 @@
+export * from "./CreateAwsLogSourceCommand";
+export * from "./CreateCustomLogSourceCommand";
+export * from "./CreateDatalakeAutoEnableCommand";
+export * from "./CreateDatalakeCommand";
+export * from "./CreateDatalakeDelegatedAdminCommand";
+export * from "./CreateDatalakeExceptionsSubscriptionCommand";
+export * from "./CreateSubscriberCommand";
+export * from "./CreateSubscriptionNotificationConfigurationCommand";
+export * from "./DeleteAwsLogSourceCommand";
+export * from "./DeleteCustomLogSourceCommand";
+export * from "./DeleteDatalakeAutoEnableCommand";
+export * from "./DeleteDatalakeCommand";
+export * from "./DeleteDatalakeDelegatedAdminCommand";
+export * from "./DeleteDatalakeExceptionsSubscriptionCommand";
+export * from "./DeleteSubscriberCommand";
+export * from "./DeleteSubscriptionNotificationConfigurationCommand";
+export * from "./GetDatalakeAutoEnableCommand";
+export * from "./GetDatalakeCommand";
+export * from "./GetDatalakeExceptionsExpiryCommand";
+export * from "./GetDatalakeExceptionsSubscriptionCommand";
+export * from "./GetDatalakeStatusCommand";
+export * from "./GetSubscriberCommand";
+export * from "./ListDatalakeExceptionsCommand";
+export * from "./ListLogSourcesCommand";
+export * from "./ListSubscribersCommand";
+export * from "./UpdateDatalakeCommand";
+export * from "./UpdateDatalakeExceptionsExpiryCommand";
+export * from "./UpdateDatalakeExceptionsSubscriptionCommand";
+export * from "./UpdateSubscriberCommand";
+export * from "./UpdateSubscriptionNotificationConfigurationCommand";

package/dist-es/endpoint/EndpointParameters.js

@@ -0,0 +1,8 @@
+export const resolveClientEndpointParameters = (options) => {
+    return {
+        ...options,
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "securitylake",
+    };
+};