com.amazonaws.services.securitylake.AmazonSecurityLake Maven / Gradle / Ivy
/*
* Copyright 2019-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.securitylake;
import javax.annotation.Generated;
import com.amazonaws.*;
import com.amazonaws.regions.*;
import com.amazonaws.services.securitylake.model.*;
/**
* Interface for accessing Amazon Security Lake.
*
* Note: Do not directly implement this interface, new methods are added to it regularly. Extend from
* {@link com.amazonaws.services.securitylake.AbstractAmazonSecurityLake} instead.
*
*
*
* 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 Services account. 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.
*
*
* The data lake is backed by Amazon Simple Storage Service (Amazon S3) buckets, and you retain ownership over your
* data.
*
*
* 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 Amazon Security Lake
* User Guide.
*
*
* 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).
*
*
* 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.
*
*/
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public interface AmazonSecurityLake {
/**
* The region metadata service name for computing region endpoints. You can use this value to retrieve metadata
* (such as supported regions) of the service.
*
* @see RegionUtils#getRegionsForService(String)
*/
String ENDPOINT_PREFIX = "securitylake";
/**
*
* 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. Once you
* add an Amazon Web Service as a source, Security Lake starts collecting logs and events from it.
*
*
* You can use this API only to enable natively supported Amazon Web Services as a source. Use
* CreateCustomLogSource to enable data collection from a custom source.
*
*
* @param createAwsLogSourceRequest
* @return Result of the CreateAwsLogSource operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.CreateAwsLogSource
* @see AWS API Documentation
*/
CreateAwsLogSourceResult createAwsLogSource(CreateAwsLogSourceRequest createAwsLogSourceRequest);
/**
*
* 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, this operation also creates an associated Glue table and an Glue crawler.
*
*
* @param createCustomLogSourceRequest
* @return Result of the CreateCustomLogSource operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.CreateCustomLogSource
* @see AWS API Documentation
*/
CreateCustomLogSourceResult createCustomLogSource(CreateCustomLogSourceRequest createCustomLogSourceRequest);
/**
*
* 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.
* To specify particular Regions, configure these Regions using the configurations 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.
*
*
* When you enable Security Lake, it starts ingesting security data after the CreateAwsLogSource 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
* Amazon Security
* Lake User Guide.
*
*
* @param createDataLakeRequest
* @return Result of the CreateDataLake operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.CreateDataLake
* @see AWS
* API Documentation
*/
CreateDataLakeResult createDataLake(CreateDataLakeRequest createDataLakeRequest);
/**
*
* Creates the specified notification subscription in Amazon Security Lake for the organization you specify.
*
*
* @param createDataLakeExceptionSubscriptionRequest
* @return Result of the CreateDataLakeExceptionSubscription operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.CreateDataLakeExceptionSubscription
* @see AWS API Documentation
*/
CreateDataLakeExceptionSubscriptionResult createDataLakeExceptionSubscription(
CreateDataLakeExceptionSubscriptionRequest createDataLakeExceptionSubscriptionRequest);
/**
*
* 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.
*
*
* @param createDataLakeOrganizationConfigurationRequest
* @return Result of the CreateDataLakeOrganizationConfiguration operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.CreateDataLakeOrganizationConfiguration
* @see AWS API Documentation
*/
CreateDataLakeOrganizationConfigurationResult createDataLakeOrganizationConfiguration(
CreateDataLakeOrganizationConfigurationRequest createDataLakeOrganizationConfigurationRequest);
/**
*
* 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.
*
*
* @param createSubscriberRequest
* @return Result of the CreateSubscriber operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.CreateSubscriber
* @see AWS
* API Documentation
*/
CreateSubscriberResult createSubscriber(CreateSubscriberRequest createSubscriberRequest);
/**
*
* 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.
*
*
* @param createSubscriberNotificationRequest
* @return Result of the CreateSubscriberNotification operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.CreateSubscriberNotification
* @see AWS API Documentation
*/
CreateSubscriberNotificationResult createSubscriberNotification(CreateSubscriberNotificationRequest createSubscriberNotificationRequest);
/**
*
* Removes a natively supported Amazon Web Service as an Amazon Security Lake source. You can remove a source for
* one or more Regions. When you remove the source, Security Lake stops collecting data from that source in the
* specified Regions and accounts, and subscribers can no longer consume new data from the source. However,
* subscribers can still consume data that Security Lake collected from the source before removal.
*
*
* 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.
*
*
* @param deleteAwsLogSourceRequest
* @return Result of the DeleteAwsLogSource operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.DeleteAwsLogSource
* @see AWS API Documentation
*/
DeleteAwsLogSourceResult deleteAwsLogSource(DeleteAwsLogSourceRequest deleteAwsLogSourceRequest);
/**
*
* Removes a custom log source from Amazon Security Lake, to stop sending data from the custom source to Security
* Lake.
*
*
* @param deleteCustomLogSourceRequest
* @return Result of the DeleteCustomLogSource operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.DeleteCustomLogSource
* @see AWS API Documentation
*/
DeleteCustomLogSourceResult deleteCustomLogSource(DeleteCustomLogSourceRequest deleteCustomLogSourceRequest);
/**
*
* When you disable Amazon Security Lake from your account, Security Lake is disabled in all Amazon Web Services
* Regions and it stops collecting data from your sources. Also, this API automatically takes steps to remove the
* account from Security Lake. However, Security Lake retains all of your existing settings and the resources that
* it created in your Amazon Web Services account in the current Amazon Web Services Region.
*
*
* The DeleteDataLake operation does not delete the data that is stored in your Amazon S3 bucket, which
* is owned by your Amazon Web Services account. For more information, see the Amazon Security Lake
* User Guide.
*
*
* @param deleteDataLakeRequest
* @return Result of the DeleteDataLake operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.DeleteDataLake
* @see AWS
* API Documentation
*/
DeleteDataLakeResult deleteDataLake(DeleteDataLakeRequest deleteDataLakeRequest);
/**
*
* Deletes the specified notification subscription in Amazon Security Lake for the organization you specify.
*
*
* @param deleteDataLakeExceptionSubscriptionRequest
* @return Result of the DeleteDataLakeExceptionSubscription operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.DeleteDataLakeExceptionSubscription
* @see AWS API Documentation
*/
DeleteDataLakeExceptionSubscriptionResult deleteDataLakeExceptionSubscription(
DeleteDataLakeExceptionSubscriptionRequest deleteDataLakeExceptionSubscriptionRequest);
/**
*
* Turns off automatic enablement of Amazon Security Lake for member accounts that are added to an organization in
* Organizations. Only the delegated Security Lake administrator for an organization can perform this operation. If
* the delegated Security Lake administrator performs this operation, new member accounts won't automatically
* contribute data to the data lake.
*
*
* @param deleteDataLakeOrganizationConfigurationRequest
* @return Result of the DeleteDataLakeOrganizationConfiguration operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.DeleteDataLakeOrganizationConfiguration
* @see AWS API Documentation
*/
DeleteDataLakeOrganizationConfigurationResult deleteDataLakeOrganizationConfiguration(
DeleteDataLakeOrganizationConfigurationRequest deleteDataLakeOrganizationConfigurationRequest);
/**
*
* Deletes the subscription permission and all notification settings for accounts that are already enabled in Amazon
* Security Lake. When you run DeleteSubscriber, the subscriber will no longer consume data from
* Security Lake and the subscriber is removed. This operation deletes the subscriber and removes access to data in
* the current Amazon Web Services Region.
*
*
* @param deleteSubscriberRequest
* @return Result of the DeleteSubscriber operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.DeleteSubscriber
* @see AWS
* API Documentation
*/
DeleteSubscriberResult deleteSubscriber(DeleteSubscriberRequest deleteSubscriberRequest);
/**
*
* Deletes the specified notification subscription in Amazon Security Lake for the organization you specify.
*
*
* @param deleteSubscriberNotificationRequest
* @return Result of the DeleteSubscriberNotification operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.DeleteSubscriberNotification
* @see AWS API Documentation
*/
DeleteSubscriberNotificationResult deleteSubscriberNotification(DeleteSubscriberNotificationRequest deleteSubscriberNotificationRequest);
/**
*
* 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.
*
*
* @param deregisterDataLakeDelegatedAdministratorRequest
* @return Result of the DeregisterDataLakeDelegatedAdministrator operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.DeregisterDataLakeDelegatedAdministrator
* @see AWS API Documentation
*/
DeregisterDataLakeDelegatedAdministratorResult deregisterDataLakeDelegatedAdministrator(
DeregisterDataLakeDelegatedAdministratorRequest deregisterDataLakeDelegatedAdministratorRequest);
/**
*
* Retrieves the details of exception notifications for the account in Amazon Security Lake.
*
*
* @param getDataLakeExceptionSubscriptionRequest
* @return Result of the GetDataLakeExceptionSubscription operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.GetDataLakeExceptionSubscription
* @see AWS API Documentation
*/
GetDataLakeExceptionSubscriptionResult getDataLakeExceptionSubscription(GetDataLakeExceptionSubscriptionRequest getDataLakeExceptionSubscriptionRequest);
/**
*
* 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.
*
*
* @param getDataLakeOrganizationConfigurationRequest
* @return Result of the GetDataLakeOrganizationConfiguration operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.GetDataLakeOrganizationConfiguration
* @see AWS API Documentation
*/
GetDataLakeOrganizationConfigurationResult getDataLakeOrganizationConfiguration(
GetDataLakeOrganizationConfigurationRequest getDataLakeOrganizationConfigurationRequest);
/**
*
* 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.
*
*
* @param getDataLakeSourcesRequest
* @return Result of the GetDataLakeSources operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.GetDataLakeSources
* @see AWS API Documentation
*/
GetDataLakeSourcesResult getDataLakeSources(GetDataLakeSourcesRequest getDataLakeSourcesRequest);
/**
*
* Retrieves the subscription information for the specified subscription ID. You can get information about a
* specific subscriber.
*
*
* @param getSubscriberRequest
* @return Result of the GetSubscriber operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.GetSubscriber
* @see AWS API
* Documentation
*/
GetSubscriberResult getSubscriber(GetSubscriberRequest getSubscriberRequest);
/**
*
* Lists the Amazon Security Lake exceptions that you can use to find the source of problems and fix them.
*
*
* @param listDataLakeExceptionsRequest
* @return Result of the ListDataLakeExceptions operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.ListDataLakeExceptions
* @see AWS API Documentation
*/
ListDataLakeExceptionsResult listDataLakeExceptions(ListDataLakeExceptionsRequest listDataLakeExceptionsRequest);
/**
*
* Retrieves the Amazon Security Lake configuration object for the specified Amazon Web Services Regions. You can
* use this operation to determine whether Security Lake is enabled for a Region.
*
*
* @param listDataLakesRequest
* @return Result of the ListDataLakes operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.ListDataLakes
* @see AWS API
* Documentation
*/
ListDataLakesResult listDataLakes(ListDataLakesRequest listDataLakesRequest);
/**
*
* Retrieves the log sources in the current Amazon Web Services Region.
*
*
* @param listLogSourcesRequest
* @return Result of the ListLogSources operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.ListLogSources
* @see AWS
* API Documentation
*/
ListLogSourcesResult listLogSources(ListLogSourcesRequest listLogSourcesRequest);
/**
*
* 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.
*
*
* @param listSubscribersRequest
* @return Result of the ListSubscribers operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.ListSubscribers
* @see AWS
* API Documentation
*/
ListSubscribersResult listSubscribers(ListSubscribersRequest listSubscribersRequest);
/**
*
* Retrieves the tags (keys and values) that are associated with an Amazon Security Lake resource: a subscriber, or
* the data lake configuration for your Amazon Web Services account in a particular Amazon Web Services Region.
*
*
* @param listTagsForResourceRequest
* @return Result of the ListTagsForResource operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.ListTagsForResource
* @see AWS API Documentation
*/
ListTagsForResourceResult listTagsForResource(ListTagsForResourceRequest listTagsForResourceRequest);
/**
*
* 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.
*
*
* @param registerDataLakeDelegatedAdministratorRequest
* @return Result of the RegisterDataLakeDelegatedAdministrator operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.RegisterDataLakeDelegatedAdministrator
* @see AWS API Documentation
*/
RegisterDataLakeDelegatedAdministratorResult registerDataLakeDelegatedAdministrator(
RegisterDataLakeDelegatedAdministratorRequest registerDataLakeDelegatedAdministratorRequest);
/**
*
* Adds or updates one or more tags that are associated with an Amazon Security Lake resource: a subscriber, or the
* data lake configuration for your Amazon Web Services account in a particular Amazon Web Services Region. A
* tag is a label that you can define and associate with Amazon Web Services resources. Each tag consists of
* a required tag key and an associated tag value. A tag key is a general label that acts as a
* category for a more specific tag value. A tag value acts as a descriptor for a tag key. Tags can help you
* identify, categorize, and manage resources in different ways, such as by owner, environment, or other criteria.
* For more information, see Tagging Amazon Security
* Lake resources in the Amazon Security Lake User Guide.
*
*
* @param tagResourceRequest
* @return Result of the TagResource operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.TagResource
* @see AWS API
* Documentation
*/
TagResourceResult tagResource(TagResourceRequest tagResourceRequest);
/**
*
* Removes one or more tags (keys and values) from an Amazon Security Lake resource: a subscriber, or the data lake
* configuration for your Amazon Web Services account in a particular Amazon Web Services Region.
*
*
* @param untagResourceRequest
* @return Result of the UntagResource operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.UntagResource
* @see AWS API
* Documentation
*/
UntagResourceResult untagResource(UntagResourceRequest untagResourceRequest);
/**
*
* 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.
*
*
* @param updateDataLakeRequest
* @return Result of the UpdateDataLake operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.UpdateDataLake
* @see AWS
* API Documentation
*/
UpdateDataLakeResult updateDataLake(UpdateDataLakeRequest updateDataLakeRequest);
/**
*
* Updates the specified notification subscription in Amazon Security Lake for the organization you specify.
*
*
* @param updateDataLakeExceptionSubscriptionRequest
* @return Result of the UpdateDataLakeExceptionSubscription operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.UpdateDataLakeExceptionSubscription
* @see AWS API Documentation
*/
UpdateDataLakeExceptionSubscriptionResult updateDataLakeExceptionSubscription(
UpdateDataLakeExceptionSubscriptionRequest updateDataLakeExceptionSubscriptionRequest);
/**
*
* 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.
*
*
* @param updateSubscriberRequest
* @return Result of the UpdateSubscriber operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.UpdateSubscriber
* @see AWS
* API Documentation
*/
UpdateSubscriberResult updateSubscriber(UpdateSubscriberRequest updateSubscriberRequest);
/**
*
* Updates an existing notification method for the subscription (SQS or HTTPs endpoint) or switches the notification
* subscription endpoint for a subscriber.
*
*
* @param updateSubscriberNotificationRequest
* @return Result of the UpdateSubscriberNotification operation returned by the service.
* @throws BadRequestException
* The request is malformed or contains an error such as an invalid parameter value or a missing required
* parameter.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InternalServerException
* Internal service exceptions are sometimes caused by transient issues. Before you start troubleshooting,
* perform the operation again.
* @throws AccessDeniedException
* You do not have sufficient access to perform this action. Access denied errors appear when Amazon
* Security Lake explicitly or implicitly denies an authorization request. An explicit denial occurs when a
* policy contains a Deny statement for the specific Amazon Web Services action. An implicit denial occurs
* when there is no applicable Deny statement and also no applicable Allow statement.
* @throws ConflictException
* Occurs when a conflict with a previous successful write is detected. This generally occurs when the
* previous write did not have time to propagate to the host serving the current request. A retry (with
* appropriate backoff logic) is the recommended response to this exception.
* @throws ThrottlingException
* The limit on the number of requests per second was exceeded.
* @sample AmazonSecurityLake.UpdateSubscriberNotification
* @see AWS API Documentation
*/
UpdateSubscriberNotificationResult updateSubscriberNotification(UpdateSubscriberNotificationRequest updateSubscriberNotificationRequest);
/**
* Shuts down this client object, releasing any resources that might be held open. This is an optional method, and
* callers are not expected to call it, but can if they want to explicitly release any open resources. Once a client
* has been shutdown, it should not be used to make any more requests.
*/
void shutdown();
/**
* Returns additional metadata for a previously executed successful request, typically used for debugging issues
* where a service isn't acting as expected. This data isn't considered part of the result data returned by an
* operation, so it's available through this separate, diagnostic interface.
*
* Response metadata is only cached for a limited period of time, so if you need to access this extra diagnostic
* information for an executed request, you should use this method to retrieve it as soon as possible after
* executing a request.
*
* @param request
* The originally executed request.
*
* @return The response metadata for the specified request, or null if none is available.
*/
ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request);
}