@aws-sdk/client-securitylake 3.220.0

package/dist-cjs/SecurityLake.js

@@ -0,0 +1,457 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityLake = void 0;
+const CreateAwsLogSourceCommand_1 = require("./commands/CreateAwsLogSourceCommand");
+const CreateCustomLogSourceCommand_1 = require("./commands/CreateCustomLogSourceCommand");
+const CreateDatalakeAutoEnableCommand_1 = require("./commands/CreateDatalakeAutoEnableCommand");
+const CreateDatalakeCommand_1 = require("./commands/CreateDatalakeCommand");
+const CreateDatalakeDelegatedAdminCommand_1 = require("./commands/CreateDatalakeDelegatedAdminCommand");
+const CreateDatalakeExceptionsSubscriptionCommand_1 = require("./commands/CreateDatalakeExceptionsSubscriptionCommand");
+const CreateSubscriberCommand_1 = require("./commands/CreateSubscriberCommand");
+const CreateSubscriptionNotificationConfigurationCommand_1 = require("./commands/CreateSubscriptionNotificationConfigurationCommand");
+const DeleteAwsLogSourceCommand_1 = require("./commands/DeleteAwsLogSourceCommand");
+const DeleteCustomLogSourceCommand_1 = require("./commands/DeleteCustomLogSourceCommand");
+const DeleteDatalakeAutoEnableCommand_1 = require("./commands/DeleteDatalakeAutoEnableCommand");
+const DeleteDatalakeCommand_1 = require("./commands/DeleteDatalakeCommand");
+const DeleteDatalakeDelegatedAdminCommand_1 = require("./commands/DeleteDatalakeDelegatedAdminCommand");
+const DeleteDatalakeExceptionsSubscriptionCommand_1 = require("./commands/DeleteDatalakeExceptionsSubscriptionCommand");
+const DeleteSubscriberCommand_1 = require("./commands/DeleteSubscriberCommand");
+const DeleteSubscriptionNotificationConfigurationCommand_1 = require("./commands/DeleteSubscriptionNotificationConfigurationCommand");
+const GetDatalakeAutoEnableCommand_1 = require("./commands/GetDatalakeAutoEnableCommand");
+const GetDatalakeCommand_1 = require("./commands/GetDatalakeCommand");
+const GetDatalakeExceptionsExpiryCommand_1 = require("./commands/GetDatalakeExceptionsExpiryCommand");
+const GetDatalakeExceptionsSubscriptionCommand_1 = require("./commands/GetDatalakeExceptionsSubscriptionCommand");
+const GetDatalakeStatusCommand_1 = require("./commands/GetDatalakeStatusCommand");
+const GetSubscriberCommand_1 = require("./commands/GetSubscriberCommand");
+const ListDatalakeExceptionsCommand_1 = require("./commands/ListDatalakeExceptionsCommand");
+const ListLogSourcesCommand_1 = require("./commands/ListLogSourcesCommand");
+const ListSubscribersCommand_1 = require("./commands/ListSubscribersCommand");
+const UpdateDatalakeCommand_1 = require("./commands/UpdateDatalakeCommand");
+const UpdateDatalakeExceptionsExpiryCommand_1 = require("./commands/UpdateDatalakeExceptionsExpiryCommand");
+const UpdateDatalakeExceptionsSubscriptionCommand_1 = require("./commands/UpdateDatalakeExceptionsSubscriptionCommand");
+const UpdateSubscriberCommand_1 = require("./commands/UpdateSubscriberCommand");
+const UpdateSubscriptionNotificationConfigurationCommand_1 = require("./commands/UpdateSubscriptionNotificationConfigurationCommand");
+const SecurityLakeClient_1 = require("./SecurityLakeClient");
+class SecurityLake extends SecurityLakeClient_1.SecurityLakeClient {
+    createAwsLogSource(args, optionsOrCb, cb) {
+        const command = new CreateAwsLogSourceCommand_1.CreateAwsLogSourceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    createCustomLogSource(args, optionsOrCb, cb) {
+        const command = new CreateCustomLogSourceCommand_1.CreateCustomLogSourceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    createDatalake(args, optionsOrCb, cb) {
+        const command = new CreateDatalakeCommand_1.CreateDatalakeCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    createDatalakeAutoEnable(args, optionsOrCb, cb) {
+        const command = new CreateDatalakeAutoEnableCommand_1.CreateDatalakeAutoEnableCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    createDatalakeDelegatedAdmin(args, optionsOrCb, cb) {
+        const command = new CreateDatalakeDelegatedAdminCommand_1.CreateDatalakeDelegatedAdminCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    createDatalakeExceptionsSubscription(args, optionsOrCb, cb) {
+        const command = new CreateDatalakeExceptionsSubscriptionCommand_1.CreateDatalakeExceptionsSubscriptionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    createSubscriber(args, optionsOrCb, cb) {
+        const command = new CreateSubscriberCommand_1.CreateSubscriberCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    createSubscriptionNotificationConfiguration(args, optionsOrCb, cb) {
+        const command = new CreateSubscriptionNotificationConfigurationCommand_1.CreateSubscriptionNotificationConfigurationCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    deleteAwsLogSource(args, optionsOrCb, cb) {
+        const command = new DeleteAwsLogSourceCommand_1.DeleteAwsLogSourceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    deleteCustomLogSource(args, optionsOrCb, cb) {
+        const command = new DeleteCustomLogSourceCommand_1.DeleteCustomLogSourceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    deleteDatalake(args, optionsOrCb, cb) {
+        const command = new DeleteDatalakeCommand_1.DeleteDatalakeCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    deleteDatalakeAutoEnable(args, optionsOrCb, cb) {
+        const command = new DeleteDatalakeAutoEnableCommand_1.DeleteDatalakeAutoEnableCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    deleteDatalakeDelegatedAdmin(args, optionsOrCb, cb) {
+        const command = new DeleteDatalakeDelegatedAdminCommand_1.DeleteDatalakeDelegatedAdminCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    deleteDatalakeExceptionsSubscription(args, optionsOrCb, cb) {
+        const command = new DeleteDatalakeExceptionsSubscriptionCommand_1.DeleteDatalakeExceptionsSubscriptionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    deleteSubscriber(args, optionsOrCb, cb) {
+        const command = new DeleteSubscriberCommand_1.DeleteSubscriberCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    deleteSubscriptionNotificationConfiguration(args, optionsOrCb, cb) {
+        const command = new DeleteSubscriptionNotificationConfigurationCommand_1.DeleteSubscriptionNotificationConfigurationCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    getDatalake(args, optionsOrCb, cb) {
+        const command = new GetDatalakeCommand_1.GetDatalakeCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    getDatalakeAutoEnable(args, optionsOrCb, cb) {
+        const command = new GetDatalakeAutoEnableCommand_1.GetDatalakeAutoEnableCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    getDatalakeExceptionsExpiry(args, optionsOrCb, cb) {
+        const command = new GetDatalakeExceptionsExpiryCommand_1.GetDatalakeExceptionsExpiryCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    getDatalakeExceptionsSubscription(args, optionsOrCb, cb) {
+        const command = new GetDatalakeExceptionsSubscriptionCommand_1.GetDatalakeExceptionsSubscriptionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    getDatalakeStatus(args, optionsOrCb, cb) {
+        const command = new GetDatalakeStatusCommand_1.GetDatalakeStatusCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    getSubscriber(args, optionsOrCb, cb) {
+        const command = new GetSubscriberCommand_1.GetSubscriberCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    listDatalakeExceptions(args, optionsOrCb, cb) {
+        const command = new ListDatalakeExceptionsCommand_1.ListDatalakeExceptionsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    listLogSources(args, optionsOrCb, cb) {
+        const command = new ListLogSourcesCommand_1.ListLogSourcesCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    listSubscribers(args, optionsOrCb, cb) {
+        const command = new ListSubscribersCommand_1.ListSubscribersCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    updateDatalake(args, optionsOrCb, cb) {
+        const command = new UpdateDatalakeCommand_1.UpdateDatalakeCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    updateDatalakeExceptionsExpiry(args, optionsOrCb, cb) {
+        const command = new UpdateDatalakeExceptionsExpiryCommand_1.UpdateDatalakeExceptionsExpiryCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    updateDatalakeExceptionsSubscription(args, optionsOrCb, cb) {
+        const command = new UpdateDatalakeExceptionsSubscriptionCommand_1.UpdateDatalakeExceptionsSubscriptionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    updateSubscriber(args, optionsOrCb, cb) {
+        const command = new UpdateSubscriberCommand_1.UpdateSubscriberCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    updateSubscriptionNotificationConfiguration(args, optionsOrCb, cb) {
+        const command = new UpdateSubscriptionNotificationConfigurationCommand_1.UpdateSubscriptionNotificationConfigurationCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+}
+exports.SecurityLake = SecurityLake;

package/dist-cjs/SecurityLakeClient.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityLakeClient = void 0;
+const config_resolver_1 = require("@aws-sdk/config-resolver");
+const middleware_content_length_1 = require("@aws-sdk/middleware-content-length");
+const middleware_endpoint_1 = require("@aws-sdk/middleware-endpoint");
+const middleware_host_header_1 = require("@aws-sdk/middleware-host-header");
+const middleware_logger_1 = require("@aws-sdk/middleware-logger");
+const middleware_recursion_detection_1 = require("@aws-sdk/middleware-recursion-detection");
+const middleware_retry_1 = require("@aws-sdk/middleware-retry");
+const middleware_signing_1 = require("@aws-sdk/middleware-signing");
+const middleware_user_agent_1 = require("@aws-sdk/middleware-user-agent");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const EndpointParameters_1 = require("./endpoint/EndpointParameters");
+const runtimeConfig_1 = require("./runtimeConfig");
+class SecurityLakeClient extends smithy_client_1.Client {
+    constructor(configuration) {
+        const _config_0 = (0, runtimeConfig_1.getRuntimeConfig)(configuration);
+        const _config_1 = (0, EndpointParameters_1.resolveClientEndpointParameters)(_config_0);
+        const _config_2 = (0, config_resolver_1.resolveRegionConfig)(_config_1);
+        const _config_3 = (0, middleware_endpoint_1.resolveEndpointConfig)(_config_2);
+        const _config_4 = (0, middleware_retry_1.resolveRetryConfig)(_config_3);
+        const _config_5 = (0, middleware_host_header_1.resolveHostHeaderConfig)(_config_4);
+        const _config_6 = (0, middleware_signing_1.resolveAwsAuthConfig)(_config_5);
+        const _config_7 = (0, middleware_user_agent_1.resolveUserAgentConfig)(_config_6);
+        super(_config_7);
+        this.config = _config_7;
+        this.middlewareStack.use((0, middleware_retry_1.getRetryPlugin)(this.config));
+        this.middlewareStack.use((0, middleware_content_length_1.getContentLengthPlugin)(this.config));
+        this.middlewareStack.use((0, middleware_host_header_1.getHostHeaderPlugin)(this.config));
+        this.middlewareStack.use((0, middleware_logger_1.getLoggerPlugin)(this.config));
+        this.middlewareStack.use((0, middleware_recursion_detection_1.getRecursionDetectionPlugin)(this.config));
+        this.middlewareStack.use((0, middleware_signing_1.getAwsAuthPlugin)(this.config));
+        this.middlewareStack.use((0, middleware_user_agent_1.getUserAgentPlugin)(this.config));
+    }
+    destroy() {
+        super.destroy();
+    }
+}
+exports.SecurityLakeClient = SecurityLakeClient;

package/dist-cjs/commands/CreateAwsLogSourceCommand.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateAwsLogSourceCommand = void 0;
+const middleware_endpoint_1 = require("@aws-sdk/middleware-endpoint");
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restJson1_1 = require("../protocols/Aws_restJson1");
+class CreateAwsLogSourceCommand extends smithy_client_1.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((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CreateAwsLogSourceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "CreateAwsLogSourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateAwsLogSourceRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateAwsLogSourceResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_restJson1_1.serializeAws_restJson1CreateAwsLogSourceCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_restJson1_1.deserializeAws_restJson1CreateAwsLogSourceCommand)(output, context);
+    }
+}
+exports.CreateAwsLogSourceCommand = CreateAwsLogSourceCommand;

package/dist-cjs/commands/CreateCustomLogSourceCommand.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateCustomLogSourceCommand = void 0;
+const middleware_endpoint_1 = require("@aws-sdk/middleware-endpoint");
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restJson1_1 = require("../protocols/Aws_restJson1");
+class CreateCustomLogSourceCommand extends smithy_client_1.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((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.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: models_0_1.CreateCustomLogSourceRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateCustomLogSourceResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_restJson1_1.serializeAws_restJson1CreateCustomLogSourceCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_restJson1_1.deserializeAws_restJson1CreateCustomLogSourceCommand)(output, context);
+    }
+}
+exports.CreateCustomLogSourceCommand = CreateCustomLogSourceCommand;

package/dist-cjs/commands/CreateDatalakeAutoEnableCommand.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateDatalakeAutoEnableCommand = void 0;
+const middleware_endpoint_1 = require("@aws-sdk/middleware-endpoint");
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restJson1_1 = require("../protocols/Aws_restJson1");
+class CreateDatalakeAutoEnableCommand extends smithy_client_1.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((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.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: models_0_1.CreateDatalakeAutoEnableRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateDatalakeAutoEnableResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_restJson1_1.serializeAws_restJson1CreateDatalakeAutoEnableCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_restJson1_1.deserializeAws_restJson1CreateDatalakeAutoEnableCommand)(output, context);
+    }
+}
+exports.CreateDatalakeAutoEnableCommand = CreateDatalakeAutoEnableCommand;