@aws-sdk/client-securitylake 3.220.0

package/dist-types/commands/DeleteSubscriberCommand.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 { DeleteSubscriberRequest, DeleteSubscriberResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface DeleteSubscriberCommandInput extends DeleteSubscriberRequest {
+}
+export interface DeleteSubscriberCommandOutput extends DeleteSubscriberResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes the specified subscription permissions to Security Lake. Deletes the specified subscription permissions from the specified organization. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, DeleteSubscriberCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, DeleteSubscriberCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new DeleteSubscriberCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteSubscriberCommandInput} for command's `input` shape.
+ * @see {@link DeleteSubscriberCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class DeleteSubscriberCommand extends $Command<DeleteSubscriberCommandInput, DeleteSubscriberCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: DeleteSubscriberCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteSubscriberCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSubscriberCommandInput, DeleteSubscriberCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteSubscriptionNotificationConfigurationCommand.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 { DeleteSubscriptionNotificationConfigurationRequest, DeleteSubscriptionNotificationConfigurationResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface DeleteSubscriptionNotificationConfigurationCommandInput extends DeleteSubscriptionNotificationConfigurationRequest {
+}
+export interface DeleteSubscriptionNotificationConfigurationCommandOutput extends DeleteSubscriptionNotificationConfigurationResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes the specified notification subscription in Security Lake. Deletes 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, DeleteSubscriptionNotificationConfigurationCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, DeleteSubscriptionNotificationConfigurationCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new DeleteSubscriptionNotificationConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteSubscriptionNotificationConfigurationCommandInput} for command's `input` shape.
+ * @see {@link DeleteSubscriptionNotificationConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class DeleteSubscriptionNotificationConfigurationCommand extends $Command<DeleteSubscriptionNotificationConfigurationCommandInput, DeleteSubscriptionNotificationConfigurationCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: DeleteSubscriptionNotificationConfigurationCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteSubscriptionNotificationConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSubscriptionNotificationConfigurationCommandInput, DeleteSubscriptionNotificationConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetDatalakeAutoEnableCommand.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 { GetDatalakeAutoEnableRequest, GetDatalakeAutoEnableResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface GetDatalakeAutoEnableCommandInput extends GetDatalakeAutoEnableRequest {
+}
+export interface GetDatalakeAutoEnableCommandOutput extends GetDatalakeAutoEnableResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves the configuration that will be automatically set up for accounts added to the organization after the organization has on boarded to Amazon Security Lake. This API does not take input parameters.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, GetDatalakeAutoEnableCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, GetDatalakeAutoEnableCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new GetDatalakeAutoEnableCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDatalakeAutoEnableCommandInput} for command's `input` shape.
+ * @see {@link GetDatalakeAutoEnableCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class GetDatalakeAutoEnableCommand extends $Command<GetDatalakeAutoEnableCommandInput, GetDatalakeAutoEnableCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: GetDatalakeAutoEnableCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetDatalakeAutoEnableCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDatalakeAutoEnableCommandInput, GetDatalakeAutoEnableCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetDatalakeCommand.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 { GetDatalakeRequest, GetDatalakeResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface GetDatalakeCommandInput extends GetDatalakeRequest {
+}
+export interface GetDatalakeCommandOutput extends GetDatalakeResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieve the Security Lake configuration object for the specified account ID. This API does not take input parameters. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, GetDatalakeCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, GetDatalakeCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new GetDatalakeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDatalakeCommandInput} for command's `input` shape.
+ * @see {@link GetDatalakeCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class GetDatalakeCommand extends $Command<GetDatalakeCommandInput, GetDatalakeCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: GetDatalakeCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetDatalakeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDatalakeCommandInput, GetDatalakeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetDatalakeExceptionsExpiryCommand.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 { GetDatalakeExceptionsExpiryRequest, GetDatalakeExceptionsExpiryResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface GetDatalakeExceptionsExpiryCommandInput extends GetDatalakeExceptionsExpiryRequest {
+}
+export interface GetDatalakeExceptionsExpiryCommandOutput extends GetDatalakeExceptionsExpiryResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves the expiration period and time-to-live (TTL) for which the exception message will remain. Exceptions are stored by default, for a 2 week period of time from when a record was
+ *          created in Security Lake. This API does not take input parameters. This API does not take input parameters.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, GetDatalakeExceptionsExpiryCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, GetDatalakeExceptionsExpiryCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new GetDatalakeExceptionsExpiryCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDatalakeExceptionsExpiryCommandInput} for command's `input` shape.
+ * @see {@link GetDatalakeExceptionsExpiryCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class GetDatalakeExceptionsExpiryCommand extends $Command<GetDatalakeExceptionsExpiryCommandInput, GetDatalakeExceptionsExpiryCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: GetDatalakeExceptionsExpiryCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetDatalakeExceptionsExpiryCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDatalakeExceptionsExpiryCommandInput, GetDatalakeExceptionsExpiryCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetDatalakeExceptionsSubscriptionCommand.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 { GetDatalakeExceptionsSubscriptionRequest, GetDatalakeExceptionsSubscriptionResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface GetDatalakeExceptionsSubscriptionCommandInput extends GetDatalakeExceptionsSubscriptionRequest {
+}
+export interface GetDatalakeExceptionsSubscriptionCommandOutput extends GetDatalakeExceptionsSubscriptionResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves the details of exception notifications for the account in Amazon Security Lake.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, GetDatalakeExceptionsSubscriptionCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, GetDatalakeExceptionsSubscriptionCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new GetDatalakeExceptionsSubscriptionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDatalakeExceptionsSubscriptionCommandInput} for command's `input` shape.
+ * @see {@link GetDatalakeExceptionsSubscriptionCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class GetDatalakeExceptionsSubscriptionCommand extends $Command<GetDatalakeExceptionsSubscriptionCommandInput, GetDatalakeExceptionsSubscriptionCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: GetDatalakeExceptionsSubscriptionCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetDatalakeExceptionsSubscriptionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDatalakeExceptionsSubscriptionCommandInput, GetDatalakeExceptionsSubscriptionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetDatalakeStatusCommand.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 { GetDatalakeStatusRequest, GetDatalakeStatusResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface GetDatalakeStatusCommandInput extends GetDatalakeStatusRequest {
+}
+export interface GetDatalakeStatusCommandOutput extends GetDatalakeStatusResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieve the Security Lake configuration object for the specified account ID. This API does not take input parameters. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, GetDatalakeStatusCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, GetDatalakeStatusCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new GetDatalakeStatusCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDatalakeStatusCommandInput} for command's `input` shape.
+ * @see {@link GetDatalakeStatusCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class GetDatalakeStatusCommand extends $Command<GetDatalakeStatusCommandInput, GetDatalakeStatusCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: GetDatalakeStatusCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetDatalakeStatusCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDatalakeStatusCommandInput, GetDatalakeStatusCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSubscriberCommand.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 { GetSubscriberRequest, GetSubscriberResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface GetSubscriberCommandInput extends GetSubscriberRequest {
+}
+export interface GetSubscriberCommandOutput extends GetSubscriberResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves subscription information for the specified subscription ID.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, GetSubscriberCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, GetSubscriberCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new GetSubscriberCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSubscriberCommandInput} for command's `input` shape.
+ * @see {@link GetSubscriberCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class GetSubscriberCommand extends $Command<GetSubscriberCommandInput, GetSubscriberCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: GetSubscriberCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetSubscriberCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSubscriberCommandInput, GetSubscriberCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListDatalakeExceptionsCommand.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 { ListDatalakeExceptionsRequest, ListDatalakeExceptionsResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface ListDatalakeExceptionsCommandInput extends ListDatalakeExceptionsRequest {
+}
+export interface ListDatalakeExceptionsCommandOutput extends ListDatalakeExceptionsResponse, __MetadataBearer {
+}
+/**
+ * <p>List the Amazon Security Lake exceptions that you can use to find the source of problems and fix them.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, ListDatalakeExceptionsCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, ListDatalakeExceptionsCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new ListDatalakeExceptionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDatalakeExceptionsCommandInput} for command's `input` shape.
+ * @see {@link ListDatalakeExceptionsCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class ListDatalakeExceptionsCommand extends $Command<ListDatalakeExceptionsCommandInput, ListDatalakeExceptionsCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: ListDatalakeExceptionsCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListDatalakeExceptionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDatalakeExceptionsCommandInput, ListDatalakeExceptionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListLogSourcesCommand.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 { ListLogSourcesRequest, ListLogSourcesResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface ListLogSourcesCommandInput extends ListLogSourcesRequest {
+}
+export interface ListLogSourcesCommandOutput extends ListLogSourcesResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the log sources in the current region.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, ListLogSourcesCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, ListLogSourcesCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new ListLogSourcesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListLogSourcesCommandInput} for command's `input` shape.
+ * @see {@link ListLogSourcesCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class ListLogSourcesCommand extends $Command<ListLogSourcesCommandInput, ListLogSourcesCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: ListLogSourcesCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListLogSourcesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListLogSourcesCommandInput, ListLogSourcesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListSubscribersCommand.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 { ListSubscribersRequest, ListSubscribersResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface ListSubscribersCommandInput extends ListSubscribersRequest {
+}
+export interface ListSubscribersCommandOutput extends ListSubscribersResponse, __MetadataBearer {
+}
+/**
+ * <p>List all subscribers for the specific Security Lake account ID.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, ListSubscribersCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, ListSubscribersCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new ListSubscribersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListSubscribersCommandInput} for command's `input` shape.
+ * @see {@link ListSubscribersCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class ListSubscribersCommand extends $Command<ListSubscribersCommandInput, ListSubscribersCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: ListSubscribersCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListSubscribersCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSubscribersCommandInput, ListSubscribersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,40 @@
+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 { UpdateDatalakeRequest, UpdateDatalakeResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface UpdateDatalakeCommandInput extends UpdateDatalakeRequest {
+}
+export interface UpdateDatalakeCommandOutput extends UpdateDatalakeResponse, __MetadataBearer {
+}
+/**
+ * <p>Amazon Security Lake allows you to specify where to store your security data and for how long.
+ *          You can specify a rollup Region to consolidate data from multiple regions. </p>
+ *          <p>You can update the properties of a Region or source. Input can either be directly
+ *          specified to the API. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, UpdateDatalakeCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, UpdateDatalakeCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new UpdateDatalakeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateDatalakeCommandInput} for command's `input` shape.
+ * @see {@link UpdateDatalakeCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class UpdateDatalakeCommand extends $Command<UpdateDatalakeCommandInput, UpdateDatalakeCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: UpdateDatalakeCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: UpdateDatalakeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDatalakeCommandInput, UpdateDatalakeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,40 @@
+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 { UpdateDatalakeExceptionsExpiryRequest, UpdateDatalakeExceptionsExpiryResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface UpdateDatalakeExceptionsExpiryCommandInput extends UpdateDatalakeExceptionsExpiryRequest {
+}
+export interface UpdateDatalakeExceptionsExpiryCommandOutput extends UpdateDatalakeExceptionsExpiryResponse, __MetadataBearer {
+}
+/**
+ * <p>Update the expiration period for the exception message to your preferred time, and control
+ *          the time-to-live (TTL) for the exception message to remain.
+ *          Exceptions are stored by default, for a 2 week period of time from when a record was
+ *          created in Security Lake. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, UpdateDatalakeExceptionsExpiryCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, UpdateDatalakeExceptionsExpiryCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new UpdateDatalakeExceptionsExpiryCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateDatalakeExceptionsExpiryCommandInput} for command's `input` shape.
+ * @see {@link UpdateDatalakeExceptionsExpiryCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class UpdateDatalakeExceptionsExpiryCommand extends $Command<UpdateDatalakeExceptionsExpiryCommandInput, UpdateDatalakeExceptionsExpiryCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: UpdateDatalakeExceptionsExpiryCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: UpdateDatalakeExceptionsExpiryCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDatalakeExceptionsExpiryCommandInput, UpdateDatalakeExceptionsExpiryCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateDatalakeExceptionsSubscriptionCommand.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 { UpdateDatalakeExceptionsSubscriptionRequest, UpdateDatalakeExceptionsSubscriptionResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface UpdateDatalakeExceptionsSubscriptionCommandInput extends UpdateDatalakeExceptionsSubscriptionRequest {
+}
+export interface UpdateDatalakeExceptionsSubscriptionCommandOutput extends UpdateDatalakeExceptionsSubscriptionResponse, __MetadataBearer {
+}
+/**
+ * <p>Update the subscription notification for exception notification.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, UpdateDatalakeExceptionsSubscriptionCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, UpdateDatalakeExceptionsSubscriptionCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new UpdateDatalakeExceptionsSubscriptionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateDatalakeExceptionsSubscriptionCommandInput} for command's `input` shape.
+ * @see {@link UpdateDatalakeExceptionsSubscriptionCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class UpdateDatalakeExceptionsSubscriptionCommand extends $Command<UpdateDatalakeExceptionsSubscriptionCommandInput, UpdateDatalakeExceptionsSubscriptionCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: UpdateDatalakeExceptionsSubscriptionCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: UpdateDatalakeExceptionsSubscriptionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDatalakeExceptionsSubscriptionCommandInput, UpdateDatalakeExceptionsSubscriptionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateSubscriberCommand.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 { UpdateSubscriberRequest, UpdateSubscriberResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface UpdateSubscriberCommandInput extends UpdateSubscriberRequest {
+}
+export interface UpdateSubscriberCommandOutput extends UpdateSubscriberResponse, __MetadataBearer {
+}
+/**
+ * <p>Update the subscription permission for the given Security Lake account ID.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, UpdateSubscriberCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, UpdateSubscriberCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new UpdateSubscriberCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateSubscriberCommandInput} for command's `input` shape.
+ * @see {@link UpdateSubscriberCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class UpdateSubscriberCommand extends $Command<UpdateSubscriberCommandInput, UpdateSubscriberCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: UpdateSubscriberCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: UpdateSubscriberCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateSubscriberCommandInput, UpdateSubscriberCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateSubscriptionNotificationConfigurationCommand.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 { UpdateSubscriptionNotificationConfigurationRequest, UpdateSubscriptionNotificationConfigurationResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+export interface UpdateSubscriptionNotificationConfigurationCommandInput extends UpdateSubscriptionNotificationConfigurationRequest {
+}
+export interface UpdateSubscriptionNotificationConfigurationCommandOutput extends UpdateSubscriptionNotificationConfigurationResponse, __MetadataBearer {
+}
+/**
+ * <p>Create a new subscription notification or add the existing subscription notification
+ *          setting for the specified subscription ID.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SecurityLakeClient, UpdateSubscriptionNotificationConfigurationCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, UpdateSubscriptionNotificationConfigurationCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const command = new UpdateSubscriptionNotificationConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateSubscriptionNotificationConfigurationCommandInput} for command's `input` shape.
+ * @see {@link UpdateSubscriptionNotificationConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
+ *
+ */
+export declare class UpdateSubscriptionNotificationConfigurationCommand extends $Command<UpdateSubscriptionNotificationConfigurationCommandInput, UpdateSubscriptionNotificationConfigurationCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: UpdateSubscriptionNotificationConfigurationCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: UpdateSubscriptionNotificationConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateSubscriptionNotificationConfigurationCommandInput, UpdateSubscriptionNotificationConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}