@aws-sdk/client-securitylake 3.220.0

package/dist-types/commands/CreateAwsLogSourceCommand.d.ts

@@ -0,0 +1,51 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateAwsLogSourceRequest, CreateAwsLogSourceResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface CreateAwsLogSourceCommandInput extends CreateAwsLogSourceRequest {
+}
+export interface CreateAwsLogSourceCommandOutput extends CreateAwsLogSourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Adds a natively-supported Amazon Web Services service as a Security Lake source. Enables
+ *          source types for member accounts in required Regions, based on specified parameters. You
+ *          can choose any source type in any Region for accounts that are either part of a trusted
+ *          organization or standalone accounts. At least one of the three dimensions is a mandatory
+ *          input to this API. However, any combination of the three dimensions can be supplied to this
+ *          API. </p>
+ *          <p>By default, dimension refers to the entire set. When you don't provide a dimension,
+ *          Security Lake assumes that the missing dimension refers to the entire set. This is overridden
+ *          when you supply any one of the inputs. For instance, when members is not specified, the API
+ *          disables all Security Lake member accounts for sources. Similarly, when Regions are not
+ *          specified, Security Lake is disabled for all the Regions where Security Lake is available as a
+ *          service.</p>
+ *          <p>You can use this API only to enable a natively-supported Amazon Web Services services as
+ *          a source. Use <code>CreateCustomLogSource</code> to enable data collection from a custom
+ *          source. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, CreateAwsLogSourceCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, CreateAwsLogSourceCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new CreateAwsLogSourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateAwsLogSourceCommandInput} for command's `input` shape.
+ * @see {@link CreateAwsLogSourceCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class CreateAwsLogSourceCommand extends $Command<CreateAwsLogSourceCommandInput, CreateAwsLogSourceCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: CreateAwsLogSourceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CreateAwsLogSourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateAwsLogSourceCommandInput, CreateAwsLogSourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateCustomLogSourceCommand.d.ts

@@ -0,0 +1,42 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateCustomLogSourceRequest, CreateCustomLogSourceResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface CreateCustomLogSourceCommandInput extends CreateCustomLogSourceRequest {
+}
+export interface CreateCustomLogSourceCommandOutput extends CreateCustomLogSourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Adds a third-party custom source in Amazon Security Lake, from the Region where you want to
+ *          create a custom source. Security Lake can collect logs and events from third-party custom
+ *          sources. After creating the appropriate API roles, use this API to add a custom source name
+ *          in Security Lake. This operation creates a partition in the Security Lake S3 bucket as the target
+ *          location for log files from the custom source, an associated Glue table, and
+ *          an Glue crawler.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, CreateCustomLogSourceCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, CreateCustomLogSourceCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new CreateCustomLogSourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateCustomLogSourceCommandInput} for command's `input` shape.
+ * @see {@link CreateCustomLogSourceCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class CreateCustomLogSourceCommand extends $Command<CreateCustomLogSourceCommandInput, CreateCustomLogSourceCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: CreateCustomLogSourceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CreateCustomLogSourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCustomLogSourceCommandInput, CreateCustomLogSourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateDatalakeAutoEnableCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateDatalakeAutoEnableRequest, CreateDatalakeAutoEnableResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface CreateDatalakeAutoEnableCommandInput extends CreateDatalakeAutoEnableRequest {
+}
+export interface CreateDatalakeAutoEnableCommandOutput extends CreateDatalakeAutoEnableResponse, __MetadataBearer {
+}
+/**
+ * <p>Automatically enable Security Lake in the specified Regions to begin ingesting security
+ *          data. When you choose to enable organization accounts automatically, then Security Lake begins to enable new accounts as member accounts as they are added to the organization. Security Lake does not enable existing organization accounts that are not yet enabled.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, CreateDatalakeAutoEnableCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, CreateDatalakeAutoEnableCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new CreateDatalakeAutoEnableCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDatalakeAutoEnableCommandInput} for command's `input` shape.
+ * @see {@link CreateDatalakeAutoEnableCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class CreateDatalakeAutoEnableCommand extends $Command<CreateDatalakeAutoEnableCommandInput, CreateDatalakeAutoEnableCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: CreateDatalakeAutoEnableCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CreateDatalakeAutoEnableCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDatalakeAutoEnableCommandInput, CreateDatalakeAutoEnableCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateDatalakeCommand.d.ts

@@ -0,0 +1,49 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateDatalakeRequest, CreateDatalakeResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface CreateDatalakeCommandInput extends CreateDatalakeRequest {
+}
+export interface CreateDatalakeCommandOutput extends CreateDatalakeResponse, __MetadataBearer {
+}
+/**
+ * <p>Initializes an Amazon Security Lake instance with the provided (or default) configuration. You can enable Security Lake in Regions with customized settings in advance before enabling log collection in Regions. You can either use the <code>enableAll</code> parameter to
+ *          specify all Regions or you can specify the Regions you want to enable Security Lake using the
+ *          <code>Regions</code> parameter and configure these Regions using the
+ *          <code>configurations</code> parameter. When the <code>CreateDataLake</code> API is called
+ *          multiple times, if that Region is already enabled, it will update the Region if
+ *          configuration for that Region is provided. If that Region is a new Region, it will be set
+ *          up with the customized configurations if it is specified. </p>
+ *          <p>When you enable Security Lake, it starts ingesting security data after the
+ *          <code>CreateAwsLogSource</code> call. This includes ingesting security
+ *          data from sources, storing data, and making data accessible to subscribers. Security Lake also
+ *          enables all the existing settings and resources that it stores or maintains for your
+ *          account in the current Region, including security log and event data. For more information,
+ *          see the Amazon Security Lake User Guide.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, CreateDatalakeCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, CreateDatalakeCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new CreateDatalakeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDatalakeCommandInput} for command's `input` shape.
+ * @see {@link CreateDatalakeCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class CreateDatalakeCommand extends $Command<CreateDatalakeCommandInput, CreateDatalakeCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: CreateDatalakeCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CreateDatalakeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDatalakeCommandInput, CreateDatalakeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateDatalakeDelegatedAdminCommand.d.ts

@@ -0,0 +1,39 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateDatalakeDelegatedAdminRequest, CreateDatalakeDelegatedAdminResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface CreateDatalakeDelegatedAdminCommandInput extends CreateDatalakeDelegatedAdminRequest {
+}
+export interface CreateDatalakeDelegatedAdminCommandOutput extends CreateDatalakeDelegatedAdminResponse, __MetadataBearer {
+}
+/**
+ * <p>Designates the Security Lake administrator account for the organization. This API can only
+ *          be called by the organization management account. The organization management account
+ *          cannot be the delegated administrator account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, CreateDatalakeDelegatedAdminCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, CreateDatalakeDelegatedAdminCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new CreateDatalakeDelegatedAdminCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDatalakeDelegatedAdminCommandInput} for command's `input` shape.
+ * @see {@link CreateDatalakeDelegatedAdminCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class CreateDatalakeDelegatedAdminCommand extends $Command<CreateDatalakeDelegatedAdminCommandInput, CreateDatalakeDelegatedAdminCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: CreateDatalakeDelegatedAdminCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CreateDatalakeDelegatedAdminCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDatalakeDelegatedAdminCommandInput, CreateDatalakeDelegatedAdminCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateDatalakeExceptionsSubscriptionCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateDatalakeExceptionsSubscriptionRequest, CreateDatalakeExceptionsSubscriptionResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface CreateDatalakeExceptionsSubscriptionCommandInput extends CreateDatalakeExceptionsSubscriptionRequest {
+}
+export interface CreateDatalakeExceptionsSubscriptionCommandOutput extends CreateDatalakeExceptionsSubscriptionResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates the specified notification subscription in Security Lake. Creates the specified
+ *          subscription notifications in the specified organization. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, CreateDatalakeExceptionsSubscriptionCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, CreateDatalakeExceptionsSubscriptionCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new CreateDatalakeExceptionsSubscriptionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDatalakeExceptionsSubscriptionCommandInput} for command's `input` shape.
+ * @see {@link CreateDatalakeExceptionsSubscriptionCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class CreateDatalakeExceptionsSubscriptionCommand extends $Command<CreateDatalakeExceptionsSubscriptionCommandInput, CreateDatalakeExceptionsSubscriptionCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: CreateDatalakeExceptionsSubscriptionCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CreateDatalakeExceptionsSubscriptionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDatalakeExceptionsSubscriptionCommandInput, CreateDatalakeExceptionsSubscriptionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateSubscriberCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateSubscriberRequest, CreateSubscriberResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface CreateSubscriberCommandInput extends CreateSubscriberRequest {
+}
+export interface CreateSubscriberCommandOutput extends CreateSubscriberResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a subscription permission for accounts that are already enabled in Security Lake.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, CreateSubscriberCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, CreateSubscriberCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new CreateSubscriberCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateSubscriberCommandInput} for command's `input` shape.
+ * @see {@link CreateSubscriberCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class CreateSubscriberCommand extends $Command<CreateSubscriberCommandInput, CreateSubscriberCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: CreateSubscriberCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CreateSubscriberCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSubscriberCommandInput, CreateSubscriberCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateSubscriptionNotificationConfigurationCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateSubscriptionNotificationConfigurationRequest, CreateSubscriptionNotificationConfigurationResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface CreateSubscriptionNotificationConfigurationCommandInput extends CreateSubscriptionNotificationConfigurationRequest {
+}
+export interface CreateSubscriptionNotificationConfigurationCommandOutput extends CreateSubscriptionNotificationConfigurationResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates the specified notification subscription in Security Lake. Creates the specified
+ *          subscription notifications from the specified organization. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, CreateSubscriptionNotificationConfigurationCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, CreateSubscriptionNotificationConfigurationCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new CreateSubscriptionNotificationConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateSubscriptionNotificationConfigurationCommandInput} for command's `input` shape.
+ * @see {@link CreateSubscriptionNotificationConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class CreateSubscriptionNotificationConfigurationCommand extends $Command<CreateSubscriptionNotificationConfigurationCommandInput, CreateSubscriptionNotificationConfigurationCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: CreateSubscriptionNotificationConfigurationCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CreateSubscriptionNotificationConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSubscriptionNotificationConfigurationCommandInput, CreateSubscriptionNotificationConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteAwsLogSourceCommand.d.ts

@@ -0,0 +1,53 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteAwsLogSourceRequest, DeleteAwsLogSourceResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface DeleteAwsLogSourceCommandInput extends DeleteAwsLogSourceRequest {
+}
+export interface DeleteAwsLogSourceCommandOutput extends DeleteAwsLogSourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Removes a natively-supported Amazon Web Services service as a Amazon Security Lake source. When you remove the
+ *          source, Security Lake stops collecting data from that source, and subscribers can no
+ *          longer consume new data from the source. Subscribers can still consume data that Amazon
+ *          Security Lake collected from the source before disablement.</p>
+ *          <p>You can choose any source type in any Region for accounts that are either part of a
+ *          trusted organization or standalone accounts. At least one of the three dimensions is a
+ *          mandatory input to this API. However, any combination of the three dimensions can be
+ *          supplied to this API. </p>
+ *          <p>By default, dimension refers to the entire set. This is overridden when you supply any
+ *          one of the inputs. For instance, when members is not specified, the API disables all
+ *          Security Lake member accounts for sources. Similarly, when Regions are not specified, Security Lake
+ *          is disabled for all the Regions where Security Lake is available as a service.</p>
+ *          <p>You can use this API to remove a natively-supported Amazon Web Services service as a source. Use
+ *             <code>DeregisterCustomData</code> to remove a custom source.</p>
+ *          <p>When you don't provide a dimension, Security Lake  assumes that the missing dimension refers
+ *          to the entire set. For example, if you don't provide specific accounts, the API applies to
+ *          the entire set of accounts in your organization.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, DeleteAwsLogSourceCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, DeleteAwsLogSourceCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new DeleteAwsLogSourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteAwsLogSourceCommandInput} for command's `input` shape.
+ * @see {@link DeleteAwsLogSourceCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class DeleteAwsLogSourceCommand extends $Command<DeleteAwsLogSourceCommandInput, DeleteAwsLogSourceCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: DeleteAwsLogSourceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteAwsLogSourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAwsLogSourceCommandInput, DeleteAwsLogSourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteCustomLogSourceCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteCustomLogSourceRequest, DeleteCustomLogSourceResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface DeleteCustomLogSourceCommandInput extends DeleteCustomLogSourceRequest {
+}
+export interface DeleteCustomLogSourceCommandOutput extends DeleteCustomLogSourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Removes a custom log source from Security Lake.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, DeleteCustomLogSourceCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, DeleteCustomLogSourceCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new DeleteCustomLogSourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteCustomLogSourceCommandInput} for command's `input` shape.
+ * @see {@link DeleteCustomLogSourceCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class DeleteCustomLogSourceCommand extends $Command<DeleteCustomLogSourceCommandInput, DeleteCustomLogSourceCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: DeleteCustomLogSourceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteCustomLogSourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCustomLogSourceCommandInput, DeleteCustomLogSourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteDatalakeAutoEnableCommand.d.ts

@@ -0,0 +1,42 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteDatalakeAutoEnableRequest, DeleteDatalakeAutoEnableResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface DeleteDatalakeAutoEnableCommandInput extends DeleteDatalakeAutoEnableRequest {
+}
+export interface DeleteDatalakeAutoEnableCommandOutput extends DeleteDatalakeAutoEnableResponse, __MetadataBearer {
+}
+/**
+ * <p>Automatically delete Security Lake in the specified Regions to stop ingesting security data. When you delete Amazon Security Lake from your account, Security Lake is disabled in all Regions. Also, this API
+ *          automatically performs the off-boarding steps to off-board the account from Security Lake .
+ *          This includes ingesting security data from sources, storing data, and making data
+ *          accessible to subscribers. Security Lake also deletes all the existing settings and resources that
+ *          it stores or maintains for your account in the current Region, including security log and
+ *          event data. For more information, see the Amazon Security Lake User Guide. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, DeleteDatalakeAutoEnableCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, DeleteDatalakeAutoEnableCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new DeleteDatalakeAutoEnableCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteDatalakeAutoEnableCommandInput} for command's `input` shape.
+ * @see {@link DeleteDatalakeAutoEnableCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class DeleteDatalakeAutoEnableCommand extends $Command<DeleteDatalakeAutoEnableCommandInput, DeleteDatalakeAutoEnableCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: DeleteDatalakeAutoEnableCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteDatalakeAutoEnableCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDatalakeAutoEnableCommandInput, DeleteDatalakeAutoEnableCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteDatalakeCommand.d.ts

@@ -0,0 +1,43 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteDatalakeRequest, DeleteDatalakeResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface DeleteDatalakeCommandInput extends DeleteDatalakeRequest {
+}
+export interface DeleteDatalakeCommandOutput extends DeleteDatalakeResponse, __MetadataBearer {
+}
+/**
+ * <p>When you delete Amazon Security Lake from your account, Security Lake is disabled in all Regions.
+ *          Also, this API automatically performs the off-boarding steps to off-board the account from
+ *          Security Lake . This includes ingesting security data from sources, storing data, and making
+ *          data accessible to subscribers. Security Lake also deletes all the existing settings and
+ *          resources that it stores or maintains for your account in the current Region, including
+ *          security log and event data. <code>DeleteDatalake</code> does not delete the S3 bucket
+ *          which is owned by the Amazon Web Services account. For more information, see the Amazon Security Lake User Guide.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, DeleteDatalakeCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, DeleteDatalakeCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new DeleteDatalakeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteDatalakeCommandInput} for command's `input` shape.
+ * @see {@link DeleteDatalakeCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class DeleteDatalakeCommand extends $Command<DeleteDatalakeCommandInput, DeleteDatalakeCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: DeleteDatalakeCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteDatalakeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDatalakeCommandInput, DeleteDatalakeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteDatalakeDelegatedAdminCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteDatalakeDelegatedAdminRequest, DeleteDatalakeDelegatedAdminResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface DeleteDatalakeDelegatedAdminCommandInput extends DeleteDatalakeDelegatedAdminRequest {
+}
+export interface DeleteDatalakeDelegatedAdminCommandOutput extends DeleteDatalakeDelegatedAdminResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes the Security Lake administrator account for the organization. This API can only be called by the organization management account. The organization management account cannot be the delegated administrator account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, DeleteDatalakeDelegatedAdminCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, DeleteDatalakeDelegatedAdminCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new DeleteDatalakeDelegatedAdminCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteDatalakeDelegatedAdminCommandInput} for command's `input` shape.
+ * @see {@link DeleteDatalakeDelegatedAdminCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class DeleteDatalakeDelegatedAdminCommand extends $Command<DeleteDatalakeDelegatedAdminCommandInput, DeleteDatalakeDelegatedAdminCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: DeleteDatalakeDelegatedAdminCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteDatalakeDelegatedAdminCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDatalakeDelegatedAdminCommandInput, DeleteDatalakeDelegatedAdminCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteDatalakeExceptionsSubscriptionCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteDatalakeExceptionsSubscriptionRequest, DeleteDatalakeExceptionsSubscriptionResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface DeleteDatalakeExceptionsSubscriptionCommandInput extends DeleteDatalakeExceptionsSubscriptionRequest {
+}
+export interface DeleteDatalakeExceptionsSubscriptionCommandOutput extends DeleteDatalakeExceptionsSubscriptionResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes the specified notification subscription in Security Lake. Deletes the specified subscription notifications in the specified organization.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, DeleteDatalakeExceptionsSubscriptionCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, DeleteDatalakeExceptionsSubscriptionCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new DeleteDatalakeExceptionsSubscriptionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteDatalakeExceptionsSubscriptionCommandInput} for command's `input` shape.
+ * @see {@link DeleteDatalakeExceptionsSubscriptionCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class DeleteDatalakeExceptionsSubscriptionCommand extends $Command<DeleteDatalakeExceptionsSubscriptionCommandInput, DeleteDatalakeExceptionsSubscriptionCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: DeleteDatalakeExceptionsSubscriptionCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteDatalakeExceptionsSubscriptionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDatalakeExceptionsSubscriptionCommandInput, DeleteDatalakeExceptionsSubscriptionCommandOutput>;
+    private serialize;
+    private deserialize;
+}