@aws-sdk/client-securitylake 3.312.0 → 3.316.0

package/dist-types/SecurityLake.d.ts

@@ -30,338 +30,221 @@ import { UpdateDatalakeExceptionsSubscriptionCommandInput, UpdateDatalakeExcepti
 import { UpdateSubscriberCommandInput, UpdateSubscriberCommandOutput } from "./commands/UpdateSubscriberCommand";
 import { UpdateSubscriptionNotificationConfigurationCommandInput, UpdateSubscriptionNotificationConfigurationCommandOutput } from "./commands/UpdateSubscriptionNotificationConfigurationCommand";
 import { SecurityLakeClient } from "./SecurityLakeClient";
-/**
- * @public
- * <note>
- *             <p>Amazon Security Lake is in preview release. Your use of the Security Lake preview is subject to
- *             Section 2 of the <a href="http://aws.amazon.com/service-terms/">Amazon Web Services Service
- *                Terms</a>("Betas and Previews").</p>
- *          </note>
- *          <p>Amazon Security Lake is a fully managed security data lake service. You can use Security Lake to
- *          automatically centralize security data from cloud, on-premises, and custom sources into a
- *          data lake that's stored in your Amazon Web Servicesaccount. Amazon Web Services Organizations
- *          is an account management service that lets you consolidate multiple Amazon Web Services
- *          accounts into an organization that you create and centrally manage. With Organizations, you
- *          can create member accounts and invite existing accounts to join your organization.
- *          Security Lake helps you analyze security data for a more complete understanding of your
- *          security posture across the entire organization. It can also help you improve the
- *          protection of your workloads, applications, and data.</p>
- *          <p>The data lake is backed by Amazon Simple Storage Service (Amazon S3) buckets, and you
- *          retain ownership over your data.   </p>
- *          <p>Amazon Security Lake integrates with CloudTrail, a service that provides a record of
- *          actions taken by a user, role, or an Amazon Web Services service in Security Lake CloudTrail captures API calls for Security Lake as events. The calls captured include calls
- *          from the Security Lake console and code calls to the Security Lake API operations. If you create a
- *          trail, you can enable continuous delivery of CloudTrail events to an Amazon S3 bucket, including events for Security Lake. If you don't configure a trail, you can still
- *          view the most recent events in the CloudTrail console in Event history. Using the
- *          information collected by CloudTrail you can determine the request that was made to
- *          Security Lake, the IP address from which the request was made, who made the request, when it
- *          was made, and additional details. To learn more about Security Lake information in CloudTrail, see the <a href="https://docs.aws.amazon.com/security-lake/latest/userguide/securitylake-cloudtrail.html">Amazon Security Lake User Guide</a>.</p>
- *          <p>Security Lake automates the collection of security-related log and event data from
- *          integrated Amazon Web Services and third-party services. It also helps you manage
- *          the lifecycle of data with customizable retention and replication settings. Security Lake
- *          converts ingested data into Apache Parquet format and a standard open-source schema called
- *          the Open Cybersecurity Schema Framework (OCSF).</p>
- *          <p>Other Amazon Web Services and third-party services can subscribe to the data that's stored in Security Lake for
- *          incident response and security data analytics.</p>
- */
-export declare class SecurityLake extends SecurityLakeClient {
+export interface SecurityLake {
     /**
-     * @public
-     * <p>Adds a natively supported Amazon Web Service as an Amazon Security Lake source. Enables
-     *          source types for member accounts in required Amazon Web Services Regions, based on the
-     *          parameters you specify. You can choose any source type in any Region for either accounts
-     *          that are part of a trusted organization or standalone accounts. At least one of the three
-     *          dimensions is a mandatory input to this API. However, you can supply any combination of the
-     *          three dimensions to this API. </p>
-     *          <p>By default, a 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 you do not specify members, the
-     *          API enables all Security Lake member accounts for all sources. Similarly, when you do not
-     *          specify Regions, Security Lake is enabled for all the Regions where Security Lake is available as a
-     *          service.</p>
-     *          <p>You can use this API only to enable natively supported Amazon Web Services as a
-     *          source. Use <code>CreateCustomLogSource</code> to enable data collection from a custom
-     *          source. </p>
+     * @see {@link CreateAwsLogSourceCommand}
      */
     createAwsLogSource(args: CreateAwsLogSourceCommandInput, options?: __HttpHandlerOptions): Promise<CreateAwsLogSourceCommandOutput>;
     createAwsLogSource(args: CreateAwsLogSourceCommandInput, cb: (err: any, data?: CreateAwsLogSourceCommandOutput) => void): void;
     createAwsLogSource(args: CreateAwsLogSourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateAwsLogSourceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Adds a third-party custom source in Amazon Security Lake, from the Amazon Web Services 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 IAM role to
-     *          invoke Glue crawler, use this API to add a custom source name in Security Lake. This
-     *          operation creates a partition in the Amazon S3 bucket for Security Lake as the target
-     *          location for log files from the custom source in addition to an associated Glue table and an Glue crawler.</p>
+     * @see {@link CreateCustomLogSourceCommand}
      */
     createCustomLogSource(args: CreateCustomLogSourceCommandInput, options?: __HttpHandlerOptions): Promise<CreateCustomLogSourceCommandOutput>;
     createCustomLogSource(args: CreateCustomLogSourceCommandInput, cb: (err: any, data?: CreateCustomLogSourceCommandOutput) => void): void;
     createCustomLogSource(args: CreateCustomLogSourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateCustomLogSourceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Initializes an Amazon Security Lake instance with the provided (or default) configuration. You
-     *          can enable Security Lake in Amazon Web Services Regions with customized settings before enabling
-     *          log collection in Regions. You can either use the <code>enableAll</code> parameter to
-     *          specify all Regions or specify the Regions where you want to enable Security Lake. To specify
-     *          particular Regions, use the <code>Regions</code> parameter and then configure these Regions
-     *          using the <code>configurations</code> parameter. If you have already enabled Security Lake in a
-     *          Region when you call this command, the command will update the Region if you provide new
-     *          configuration parameters. If you have not already enabled Security Lake in the Region when you
-     *          call this API, it will set up the data lake in the Region with the specified
-     *          configurations.</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 Amazon Web Services account in the current Region, including security log and event data. For
-     *          more information, see the <a href="https://docs.aws.amazon.com/security-lake/latest/userguide/what-is-security-lake.html">Amazon Security Lake User
-     *             Guide</a>.</p>
+     * @see {@link CreateDatalakeCommand}
      */
     createDatalake(args: CreateDatalakeCommandInput, options?: __HttpHandlerOptions): Promise<CreateDatalakeCommandOutput>;
     createDatalake(args: CreateDatalakeCommandInput, cb: (err: any, data?: CreateDatalakeCommandOutput) => void): void;
     createDatalake(args: CreateDatalakeCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateDatalakeCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Automatically enables Amazon Security Lake for new member accounts in your organization.
-     *          Security Lake is not automatically enabled for any existing member accounts in your
-     *          organization.</p>
+     * @see {@link CreateDatalakeAutoEnableCommand}
      */
     createDatalakeAutoEnable(args: CreateDatalakeAutoEnableCommandInput, options?: __HttpHandlerOptions): Promise<CreateDatalakeAutoEnableCommandOutput>;
     createDatalakeAutoEnable(args: CreateDatalakeAutoEnableCommandInput, cb: (err: any, data?: CreateDatalakeAutoEnableCommandOutput) => void): void;
     createDatalakeAutoEnable(args: CreateDatalakeAutoEnableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateDatalakeAutoEnableCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Designates the Amazon Security Lake delegated 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>
+     * @see {@link CreateDatalakeDelegatedAdminCommand}
      */
     createDatalakeDelegatedAdmin(args: CreateDatalakeDelegatedAdminCommandInput, options?: __HttpHandlerOptions): Promise<CreateDatalakeDelegatedAdminCommandOutput>;
     createDatalakeDelegatedAdmin(args: CreateDatalakeDelegatedAdminCommandInput, cb: (err: any, data?: CreateDatalakeDelegatedAdminCommandOutput) => void): void;
     createDatalakeDelegatedAdmin(args: CreateDatalakeDelegatedAdminCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateDatalakeDelegatedAdminCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Creates the specified notification subscription in Amazon Security Lake for the organization
-     *          you specify.</p>
+     * @see {@link CreateDatalakeExceptionsSubscriptionCommand}
      */
     createDatalakeExceptionsSubscription(args: CreateDatalakeExceptionsSubscriptionCommandInput, options?: __HttpHandlerOptions): Promise<CreateDatalakeExceptionsSubscriptionCommandOutput>;
     createDatalakeExceptionsSubscription(args: CreateDatalakeExceptionsSubscriptionCommandInput, cb: (err: any, data?: CreateDatalakeExceptionsSubscriptionCommandOutput) => void): void;
     createDatalakeExceptionsSubscription(args: CreateDatalakeExceptionsSubscriptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateDatalakeExceptionsSubscriptionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Creates a subscription permission for accounts that are already enabled in
-     *          Amazon Security Lake. You can create a subscriber with access to data in the current Amazon Web Services Region.</p>
+     * @see {@link CreateSubscriberCommand}
      */
     createSubscriber(args: CreateSubscriberCommandInput, options?: __HttpHandlerOptions): Promise<CreateSubscriberCommandOutput>;
     createSubscriber(args: CreateSubscriberCommandInput, cb: (err: any, data?: CreateSubscriberCommandOutput) => void): void;
     createSubscriber(args: CreateSubscriberCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateSubscriberCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Notifies the subscriber when new data is written to the data lake for the sources that
-     *          the subscriber consumes in Security Lake. You can create only one subscriber notification per
-     *          subscriber.</p>
+     * @see {@link CreateSubscriptionNotificationConfigurationCommand}
      */
     createSubscriptionNotificationConfiguration(args: CreateSubscriptionNotificationConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<CreateSubscriptionNotificationConfigurationCommandOutput>;
     createSubscriptionNotificationConfiguration(args: CreateSubscriptionNotificationConfigurationCommandInput, cb: (err: any, data?: CreateSubscriptionNotificationConfigurationCommandOutput) => void): void;
     createSubscriptionNotificationConfiguration(args: CreateSubscriptionNotificationConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateSubscriptionNotificationConfigurationCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Removes a natively supported Amazon Web Service as an 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
-     *          Security Lake collected from the source before disablement.</p>
-     *          <p>You can choose any source type in any Amazon Web Services Region for either accounts that
-     *          are part of a trusted organization or standalone accounts. At least one of the three
-     *          dimensions is a mandatory input to this API. However, you can supply any combination of the
-     *          three dimensions to this API. </p>
-     *          <p>By default, a dimension refers to the entire set. This is overridden when you supply any
-     *          one of the inputs. For instance, when you do not specify members, the API disables all
-     *          Security Lake member accounts for sources. Similarly, when you do not specify Regions,
-     *          Security Lake is disabled for all the Regions where Security Lake is available as a service.</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>
+     * @see {@link DeleteAwsLogSourceCommand}
      */
     deleteAwsLogSource(args: DeleteAwsLogSourceCommandInput, options?: __HttpHandlerOptions): Promise<DeleteAwsLogSourceCommandOutput>;
     deleteAwsLogSource(args: DeleteAwsLogSourceCommandInput, cb: (err: any, data?: DeleteAwsLogSourceCommandOutput) => void): void;
     deleteAwsLogSource(args: DeleteAwsLogSourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteAwsLogSourceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Removes a custom log source from Amazon Security Lake.</p>
+     * @see {@link DeleteCustomLogSourceCommand}
      */
     deleteCustomLogSource(args: DeleteCustomLogSourceCommandInput, options?: __HttpHandlerOptions): Promise<DeleteCustomLogSourceCommandOutput>;
     deleteCustomLogSource(args: DeleteCustomLogSourceCommandInput, cb: (err: any, data?: DeleteCustomLogSourceCommandOutput) => void): void;
     deleteCustomLogSource(args: DeleteCustomLogSourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteCustomLogSourceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>When you delete Amazon Security Lake from your account, Security Lake is disabled in all Amazon Web Services Regions. Also, this API automatically takes steps to remove the account from
-     *          Security Lake . </p>
-     *          <p>This operation disables security data collection from sources, deletes data stored, and
-     *          stops making data accessible to subscribers. Security Lake also deletes all the existing
-     *          settings and resources that it stores or maintains for your Amazon Web Services account in
-     *          the current Region, including security log and event data. The <code>DeleteDatalake</code>
-     *          operation does not delete the Amazon S3 bucket, which is owned by your Amazon Web Services account. For more information, see the <a href="https://docs.aws.amazon.com/security-lake/latest/userguide/disable-security-lake.html">Amazon Security Lake User
-     *             Guide</a>.</p>
+     * @see {@link DeleteDatalakeCommand}
      */
     deleteDatalake(args: DeleteDatalakeCommandInput, options?: __HttpHandlerOptions): Promise<DeleteDatalakeCommandOutput>;
     deleteDatalake(args: DeleteDatalakeCommandInput, cb: (err: any, data?: DeleteDatalakeCommandOutput) => void): void;
     deleteDatalake(args: DeleteDatalakeCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteDatalakeCommandOutput) => void): void;
     /**
-     * @public
-     * <p>
-     *             <code>DeleteDatalakeAutoEnable</code> removes automatic enablement of configuration
-     *          settings for new member accounts (but keeps settings for the delegated administrator) from
-     *          Amazon Security Lake.  You must run this API using credentials of the delegated administrator.
-     *          When you run this API, new member accounts that are added after the organization enables
-     *          Security Lake won't contribute to the data lake.</p>
+     * @see {@link DeleteDatalakeAutoEnableCommand}
      */
     deleteDatalakeAutoEnable(args: DeleteDatalakeAutoEnableCommandInput, options?: __HttpHandlerOptions): Promise<DeleteDatalakeAutoEnableCommandOutput>;
     deleteDatalakeAutoEnable(args: DeleteDatalakeAutoEnableCommandInput, cb: (err: any, data?: DeleteDatalakeAutoEnableCommandOutput) => void): void;
     deleteDatalakeAutoEnable(args: DeleteDatalakeAutoEnableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteDatalakeAutoEnableCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the Amazon Security Lake delegated 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>
+     * @see {@link DeleteDatalakeDelegatedAdminCommand}
      */
     deleteDatalakeDelegatedAdmin(args: DeleteDatalakeDelegatedAdminCommandInput, options?: __HttpHandlerOptions): Promise<DeleteDatalakeDelegatedAdminCommandOutput>;
     deleteDatalakeDelegatedAdmin(args: DeleteDatalakeDelegatedAdminCommandInput, cb: (err: any, data?: DeleteDatalakeDelegatedAdminCommandOutput) => void): void;
     deleteDatalakeDelegatedAdmin(args: DeleteDatalakeDelegatedAdminCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteDatalakeDelegatedAdminCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the specified notification subscription in Amazon Security Lake for the organization
-     *          you specify.</p>
+     * @see {@link DeleteDatalakeExceptionsSubscriptionCommand}
      */
     deleteDatalakeExceptionsSubscription(args: DeleteDatalakeExceptionsSubscriptionCommandInput, options?: __HttpHandlerOptions): Promise<DeleteDatalakeExceptionsSubscriptionCommandOutput>;
     deleteDatalakeExceptionsSubscription(args: DeleteDatalakeExceptionsSubscriptionCommandInput, cb: (err: any, data?: DeleteDatalakeExceptionsSubscriptionCommandOutput) => void): void;
     deleteDatalakeExceptionsSubscription(args: DeleteDatalakeExceptionsSubscriptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteDatalakeExceptionsSubscriptionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the subscription permission for accounts that are already enabled in
-     *          Amazon Security Lake. You can delete a subscriber and remove access to data in the current Amazon Web Services
-     *          Region.</p>
+     * @see {@link DeleteSubscriberCommand}
      */
     deleteSubscriber(args: DeleteSubscriberCommandInput, options?: __HttpHandlerOptions): Promise<DeleteSubscriberCommandOutput>;
     deleteSubscriber(args: DeleteSubscriberCommandInput, cb: (err: any, data?: DeleteSubscriberCommandOutput) => void): void;
     deleteSubscriber(args: DeleteSubscriberCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteSubscriberCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the specified notification subscription in Amazon Security Lake for the organization
-     *          you specify.</p>
+     * @see {@link DeleteSubscriptionNotificationConfigurationCommand}
      */
     deleteSubscriptionNotificationConfiguration(args: DeleteSubscriptionNotificationConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<DeleteSubscriptionNotificationConfigurationCommandOutput>;
     deleteSubscriptionNotificationConfiguration(args: DeleteSubscriptionNotificationConfigurationCommandInput, cb: (err: any, data?: DeleteSubscriptionNotificationConfigurationCommandOutput) => void): void;
     deleteSubscriptionNotificationConfiguration(args: DeleteSubscriptionNotificationConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteSubscriptionNotificationConfigurationCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves the Amazon Security Lake configuration object for the specified Amazon Web Services account ID. You can use the <code>GetDatalake</code> API to know whether
-     *          Security Lake is enabled for the current Region. This API does not take input parameters. </p>
+     * @see {@link GetDatalakeCommand}
      */
     getDatalake(args: GetDatalakeCommandInput, options?: __HttpHandlerOptions): Promise<GetDatalakeCommandOutput>;
     getDatalake(args: GetDatalakeCommandInput, cb: (err: any, data?: GetDatalakeCommandOutput) => void): void;
     getDatalake(args: GetDatalakeCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetDatalakeCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves the configuration that will be automatically set up for accounts added to the
-     *          organization after the organization has onboarded to Amazon Security Lake. This API does not take
-     *          input parameters.</p>
+     * @see {@link GetDatalakeAutoEnableCommand}
      */
     getDatalakeAutoEnable(args: GetDatalakeAutoEnableCommandInput, options?: __HttpHandlerOptions): Promise<GetDatalakeAutoEnableCommandOutput>;
     getDatalakeAutoEnable(args: GetDatalakeAutoEnableCommandInput, cb: (err: any, data?: GetDatalakeAutoEnableCommandOutput) => void): void;
     getDatalakeAutoEnable(args: GetDatalakeAutoEnableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetDatalakeAutoEnableCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves the expiration period and time-to-live (TTL) for which the exception message
-     *          will remain. Exceptions are stored by default, for 2 weeks from when a record was created
-     *          in Amazon Security Lake. This API does not take input parameters.</p>
+     * @see {@link GetDatalakeExceptionsExpiryCommand}
      */
     getDatalakeExceptionsExpiry(args: GetDatalakeExceptionsExpiryCommandInput, options?: __HttpHandlerOptions): Promise<GetDatalakeExceptionsExpiryCommandOutput>;
     getDatalakeExceptionsExpiry(args: GetDatalakeExceptionsExpiryCommandInput, cb: (err: any, data?: GetDatalakeExceptionsExpiryCommandOutput) => void): void;
     getDatalakeExceptionsExpiry(args: GetDatalakeExceptionsExpiryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetDatalakeExceptionsExpiryCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves the details of exception notifications for the account in Amazon Security Lake.</p>
+     * @see {@link GetDatalakeExceptionsSubscriptionCommand}
      */
     getDatalakeExceptionsSubscription(args: GetDatalakeExceptionsSubscriptionCommandInput, options?: __HttpHandlerOptions): Promise<GetDatalakeExceptionsSubscriptionCommandOutput>;
     getDatalakeExceptionsSubscription(args: GetDatalakeExceptionsSubscriptionCommandInput, cb: (err: any, data?: GetDatalakeExceptionsSubscriptionCommandOutput) => void): void;
     getDatalakeExceptionsSubscription(args: GetDatalakeExceptionsSubscriptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetDatalakeExceptionsSubscriptionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves a snapshot of the current Region, including whether Amazon Security Lake is enabled
-     *          for those accounts and which sources Security Lake is collecting data from. </p>
+     * @see {@link GetDatalakeStatusCommand}
      */
     getDatalakeStatus(args: GetDatalakeStatusCommandInput, options?: __HttpHandlerOptions): Promise<GetDatalakeStatusCommandOutput>;
     getDatalakeStatus(args: GetDatalakeStatusCommandInput, cb: (err: any, data?: GetDatalakeStatusCommandOutput) => void): void;
     getDatalakeStatus(args: GetDatalakeStatusCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetDatalakeStatusCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves the subscription information for the specified subscription ID. You can get
-     *          information about a specific subscriber.</p>
+     * @see {@link GetSubscriberCommand}
      */
     getSubscriber(args: GetSubscriberCommandInput, options?: __HttpHandlerOptions): Promise<GetSubscriberCommandOutput>;
     getSubscriber(args: GetSubscriberCommandInput, cb: (err: any, data?: GetSubscriberCommandOutput) => void): void;
     getSubscriber(args: GetSubscriberCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetSubscriberCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Lists the Amazon Security Lake exceptions that you can use to find the source of problems and
-     *          fix them.</p>
+     * @see {@link ListDatalakeExceptionsCommand}
      */
     listDatalakeExceptions(args: ListDatalakeExceptionsCommandInput, options?: __HttpHandlerOptions): Promise<ListDatalakeExceptionsCommandOutput>;
     listDatalakeExceptions(args: ListDatalakeExceptionsCommandInput, cb: (err: any, data?: ListDatalakeExceptionsCommandOutput) => void): void;
     listDatalakeExceptions(args: ListDatalakeExceptionsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListDatalakeExceptionsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves the log sources in the current Amazon Web Services Region. </p>
+     * @see {@link ListLogSourcesCommand}
      */
     listLogSources(args: ListLogSourcesCommandInput, options?: __HttpHandlerOptions): Promise<ListLogSourcesCommandOutput>;
     listLogSources(args: ListLogSourcesCommandInput, cb: (err: any, data?: ListLogSourcesCommandOutput) => void): void;
     listLogSources(args: ListLogSourcesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListLogSourcesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>List all subscribers for the specific Amazon Security Lake account ID. You can retrieve a list
-     *          of subscriptions associated with a specific organization or Amazon Web Services account.</p>
+     * @see {@link ListSubscribersCommand}
      */
     listSubscribers(args: ListSubscribersCommandInput, options?: __HttpHandlerOptions): Promise<ListSubscribersCommandOutput>;
     listSubscribers(args: ListSubscribersCommandInput, cb: (err: any, data?: ListSubscribersCommandOutput) => void): void;
     listSubscribers(args: ListSubscribersCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListSubscribersCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Specifies where to store your security data and for how long. You can add a rollup
-     *          Region to consolidate data from multiple Amazon Web Services Regions. </p>
+     * @see {@link UpdateDatalakeCommand}
      */
     updateDatalake(args: UpdateDatalakeCommandInput, options?: __HttpHandlerOptions): Promise<UpdateDatalakeCommandOutput>;
     updateDatalake(args: UpdateDatalakeCommandInput, cb: (err: any, data?: UpdateDatalakeCommandOutput) => void): void;
     updateDatalake(args: UpdateDatalakeCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateDatalakeCommandOutput) => void): void;
     /**
-     * @public
-     * <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 2 weeks from when a record was created in Amazon Security Lake. </p>
+     * @see {@link UpdateDatalakeExceptionsExpiryCommand}
      */
     updateDatalakeExceptionsExpiry(args: UpdateDatalakeExceptionsExpiryCommandInput, options?: __HttpHandlerOptions): Promise<UpdateDatalakeExceptionsExpiryCommandOutput>;
     updateDatalakeExceptionsExpiry(args: UpdateDatalakeExceptionsExpiryCommandInput, cb: (err: any, data?: UpdateDatalakeExceptionsExpiryCommandOutput) => void): void;
     updateDatalakeExceptionsExpiry(args: UpdateDatalakeExceptionsExpiryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateDatalakeExceptionsExpiryCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Updates the specified notification subscription in Amazon Security Lake for the organization
-     *          you specify.</p>
+     * @see {@link UpdateDatalakeExceptionsSubscriptionCommand}
      */
     updateDatalakeExceptionsSubscription(args: UpdateDatalakeExceptionsSubscriptionCommandInput, options?: __HttpHandlerOptions): Promise<UpdateDatalakeExceptionsSubscriptionCommandOutput>;
     updateDatalakeExceptionsSubscription(args: UpdateDatalakeExceptionsSubscriptionCommandInput, cb: (err: any, data?: UpdateDatalakeExceptionsSubscriptionCommandOutput) => void): void;
     updateDatalakeExceptionsSubscription(args: UpdateDatalakeExceptionsSubscriptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateDatalakeExceptionsSubscriptionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Updates an existing subscription for the given Amazon Security Lake account ID. You can update
-     *          a subscriber by changing the sources that the subscriber consumes data from. </p>
+     * @see {@link UpdateSubscriberCommand}
      */
     updateSubscriber(args: UpdateSubscriberCommandInput, options?: __HttpHandlerOptions): Promise<UpdateSubscriberCommandOutput>;
     updateSubscriber(args: UpdateSubscriberCommandInput, cb: (err: any, data?: UpdateSubscriberCommandOutput) => void): void;
     updateSubscriber(args: UpdateSubscriberCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateSubscriberCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Updates an existing notification method for the subscription (SQS or HTTPs endpoint) or
-     *          switches the notification subscription endpoint for a subscriber.</p>
+     * @see {@link UpdateSubscriptionNotificationConfigurationCommand}
      */
     updateSubscriptionNotificationConfiguration(args: UpdateSubscriptionNotificationConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<UpdateSubscriptionNotificationConfigurationCommandOutput>;
     updateSubscriptionNotificationConfiguration(args: UpdateSubscriptionNotificationConfigurationCommandInput, cb: (err: any, data?: UpdateSubscriptionNotificationConfigurationCommandOutput) => void): void;
     updateSubscriptionNotificationConfiguration(args: UpdateSubscriptionNotificationConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateSubscriptionNotificationConfigurationCommandOutput) => void): void;
 }
+/**
+ * @public
+ * <note>
+ *             <p>Amazon Security Lake is in preview release. Your use of the Security Lake preview is subject to
+ *             Section 2 of the <a href="http://aws.amazon.com/service-terms/">Amazon Web Services Service
+ *                Terms</a>("Betas and Previews").</p>
+ *          </note>
+ *          <p>Amazon Security Lake is a fully managed security data lake service. You can use Security Lake to
+ *          automatically centralize security data from cloud, on-premises, and custom sources into a
+ *          data lake that's stored in your Amazon Web Servicesaccount. Amazon Web Services Organizations
+ *          is an account management service that lets you consolidate multiple Amazon Web Services
+ *          accounts into an organization that you create and centrally manage. With Organizations, you
+ *          can create member accounts and invite existing accounts to join your organization.
+ *          Security Lake helps you analyze security data for a more complete understanding of your
+ *          security posture across the entire organization. It can also help you improve the
+ *          protection of your workloads, applications, and data.</p>
+ *          <p>The data lake is backed by Amazon Simple Storage Service (Amazon S3) buckets, and you
+ *          retain ownership over your data.   </p>
+ *          <p>Amazon Security Lake integrates with CloudTrail, a service that provides a record of
+ *          actions taken by a user, role, or an Amazon Web Services service in Security Lake CloudTrail captures API calls for Security Lake as events. The calls captured include calls
+ *          from the Security Lake console and code calls to the Security Lake API operations. If you create a
+ *          trail, you can enable continuous delivery of CloudTrail events to an Amazon S3 bucket, including events for Security Lake. If you don't configure a trail, you can still
+ *          view the most recent events in the CloudTrail console in Event history. Using the
+ *          information collected by CloudTrail you can determine the request that was made to
+ *          Security Lake, the IP address from which the request was made, who made the request, when it
+ *          was made, and additional details. To learn more about Security Lake information in CloudTrail, see the <a href="https://docs.aws.amazon.com/security-lake/latest/userguide/securitylake-cloudtrail.html">Amazon Security Lake User Guide</a>.</p>
+ *          <p>Security Lake automates the collection of security-related log and event data from
+ *          integrated Amazon Web Services and third-party services. It also helps you manage
+ *          the lifecycle of data with customizable retention and replication settings. Security Lake
+ *          converts ingested data into Apache Parquet format and a standard open-source schema called
+ *          the Open Cybersecurity Schema Framework (OCSF).</p>
+ *          <p>Other Amazon Web Services and third-party services can subscribe to the data that's stored in Security Lake for
+ *          incident response and security data analytics.</p>
+ */
+export declare class SecurityLake extends SecurityLakeClient implements SecurityLake {
+}

package/dist-types/ts3.4/SecurityLake.d.ts

@@ -120,7 +120,7 @@ import {
   UpdateSubscriptionNotificationConfigurationCommandOutput,
 } from "./commands/UpdateSubscriptionNotificationConfigurationCommand";
 import { SecurityLakeClient } from "./SecurityLakeClient";
-export declare class SecurityLake extends SecurityLakeClient {
+export interface SecurityLake {
   createAwsLogSource(
     args: CreateAwsLogSourceCommandInput,
     options?: __HttpHandlerOptions
@@ -554,3 +554,6 @@ export declare class SecurityLake extends SecurityLakeClient {
     ) => void
   ): void;
 }
+export declare class SecurityLake
+  extends SecurityLakeClient
+  implements SecurityLake {}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-securitylake",
   "description": "AWS SDK for JavaScript Securitylake Client for Node.js, Browser and React Native",
-  "version": "3.312.0",
+  "version": "3.316.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -21,9 +21,9 @@
   "dependencies": {
     "@aws-crypto/sha256-browser": "3.0.0",
     "@aws-crypto/sha256-js": "3.0.0",
-    "@aws-sdk/client-sts": "3.312.0",
+    "@aws-sdk/client-sts": "3.316.0",
     "@aws-sdk/config-resolver": "3.310.0",
-    "@aws-sdk/credential-provider-node": "3.310.0",
+    "@aws-sdk/credential-provider-node": "3.316.0",
     "@aws-sdk/fetch-http-handler": "3.310.0",
     "@aws-sdk/hash-node": "3.310.0",
     "@aws-sdk/invalid-dependency": "3.310.0",
@@ -40,14 +40,14 @@
     "@aws-sdk/node-config-provider": "3.310.0",
     "@aws-sdk/node-http-handler": "3.310.0",
     "@aws-sdk/protocol-http": "3.310.0",
-    "@aws-sdk/smithy-client": "3.310.0",
+    "@aws-sdk/smithy-client": "3.316.0",
     "@aws-sdk/types": "3.310.0",
     "@aws-sdk/url-parser": "3.310.0",
     "@aws-sdk/util-base64": "3.310.0",
     "@aws-sdk/util-body-length-browser": "3.310.0",
     "@aws-sdk/util-body-length-node": "3.310.0",
-    "@aws-sdk/util-defaults-mode-browser": "3.310.0",
-    "@aws-sdk/util-defaults-mode-node": "3.310.0",
+    "@aws-sdk/util-defaults-mode-browser": "3.316.0",
+    "@aws-sdk/util-defaults-mode-node": "3.316.0",
     "@aws-sdk/util-endpoints": "3.310.0",
     "@aws-sdk/util-retry": "3.310.0",
     "@aws-sdk/util-user-agent-browser": "3.310.0",