/* * Copyright 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. */ /* * Do not modify this file. This file is generated from the securitylake-2018-05-10.normal.json service model. */ using System; using System.Collections.Generic; using Amazon.Runtime; using Amazon.SecurityLake.Model; namespace Amazon.SecurityLake { /// /// Interface for accessing SecurityLake /// /// 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. /// /// public partial interface IAmazonSecurityLake : IAmazonService, IDisposable { #if BCL45 || AWS_ASYNC_ENUMERABLES_API /// /// Paginators for the service /// ISecurityLakePaginatorFactory Paginators { get; } #endif #region CreateAwsLogSource /// /// 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. /// /// /// Container for the necessary parameters to execute the CreateAwsLogSource service method. /// /// The response from the CreateAwsLogSource service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for CreateAwsLogSource Operation CreateAwsLogSourceResponse CreateAwsLogSource(CreateAwsLogSourceRequest request); /// /// Initiates the asynchronous execution of the CreateAwsLogSource operation. /// /// /// Container for the necessary parameters to execute the CreateAwsLogSource operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateAwsLogSource /// operation. /// REST API Reference for CreateAwsLogSource Operation IAsyncResult BeginCreateAwsLogSource(CreateAwsLogSourceRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the CreateAwsLogSource operation. /// /// /// The IAsyncResult returned by the call to BeginCreateAwsLogSource. /// /// Returns a CreateAwsLogSourceResult from SecurityLake. /// REST API Reference for CreateAwsLogSource Operation CreateAwsLogSourceResponse EndCreateAwsLogSource(IAsyncResult asyncResult); #endregion #region CreateCustomLogSource /// /// 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. /// /// Container for the necessary parameters to execute the CreateCustomLogSource service method. /// /// The response from the CreateCustomLogSource service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for CreateCustomLogSource Operation CreateCustomLogSourceResponse CreateCustomLogSource(CreateCustomLogSourceRequest request); /// /// Initiates the asynchronous execution of the CreateCustomLogSource operation. /// /// /// Container for the necessary parameters to execute the CreateCustomLogSource operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateCustomLogSource /// operation. /// REST API Reference for CreateCustomLogSource Operation IAsyncResult BeginCreateCustomLogSource(CreateCustomLogSourceRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the CreateCustomLogSource operation. /// /// /// The IAsyncResult returned by the call to BeginCreateCustomLogSource. /// /// Returns a CreateCustomLogSourceResult from SecurityLake. /// REST API Reference for CreateCustomLogSource Operation CreateCustomLogSourceResponse EndCreateCustomLogSource(IAsyncResult asyncResult); #endregion #region CreateDataLake /// /// 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. /// /// /// Container for the necessary parameters to execute the CreateDataLake service method. /// /// The response from the CreateDataLake service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for CreateDataLake Operation CreateDataLakeResponse CreateDataLake(CreateDataLakeRequest request); /// /// Initiates the asynchronous execution of the CreateDataLake operation. /// /// /// Container for the necessary parameters to execute the CreateDataLake operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateDataLake /// operation. /// REST API Reference for CreateDataLake Operation IAsyncResult BeginCreateDataLake(CreateDataLakeRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the CreateDataLake operation. /// /// /// The IAsyncResult returned by the call to BeginCreateDataLake. /// /// Returns a CreateDataLakeResult from SecurityLake. /// REST API Reference for CreateDataLake Operation CreateDataLakeResponse EndCreateDataLake(IAsyncResult asyncResult); #endregion #region CreateDataLakeExceptionSubscription /// /// Creates the specified notification subscription in Amazon Security Lake for the organization /// you specify. /// /// Container for the necessary parameters to execute the CreateDataLakeExceptionSubscription service method. /// /// The response from the CreateDataLakeExceptionSubscription service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for CreateDataLakeExceptionSubscription Operation CreateDataLakeExceptionSubscriptionResponse CreateDataLakeExceptionSubscription(CreateDataLakeExceptionSubscriptionRequest request); /// /// Initiates the asynchronous execution of the CreateDataLakeExceptionSubscription operation. /// /// /// Container for the necessary parameters to execute the CreateDataLakeExceptionSubscription operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateDataLakeExceptionSubscription /// operation. /// REST API Reference for CreateDataLakeExceptionSubscription Operation IAsyncResult BeginCreateDataLakeExceptionSubscription(CreateDataLakeExceptionSubscriptionRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the CreateDataLakeExceptionSubscription operation. /// /// /// The IAsyncResult returned by the call to BeginCreateDataLakeExceptionSubscription. /// /// Returns a CreateDataLakeExceptionSubscriptionResult from SecurityLake. /// REST API Reference for CreateDataLakeExceptionSubscription Operation CreateDataLakeExceptionSubscriptionResponse EndCreateDataLakeExceptionSubscription(IAsyncResult asyncResult); #endregion #region CreateDataLakeOrganizationConfiguration /// /// 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. /// /// Container for the necessary parameters to execute the CreateDataLakeOrganizationConfiguration service method. /// /// The response from the CreateDataLakeOrganizationConfiguration service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for CreateDataLakeOrganizationConfiguration Operation CreateDataLakeOrganizationConfigurationResponse CreateDataLakeOrganizationConfiguration(CreateDataLakeOrganizationConfigurationRequest request); /// /// Initiates the asynchronous execution of the CreateDataLakeOrganizationConfiguration operation. /// /// /// Container for the necessary parameters to execute the CreateDataLakeOrganizationConfiguration operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateDataLakeOrganizationConfiguration /// operation. /// REST API Reference for CreateDataLakeOrganizationConfiguration Operation IAsyncResult BeginCreateDataLakeOrganizationConfiguration(CreateDataLakeOrganizationConfigurationRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the CreateDataLakeOrganizationConfiguration operation. /// /// /// The IAsyncResult returned by the call to BeginCreateDataLakeOrganizationConfiguration. /// /// Returns a CreateDataLakeOrganizationConfigurationResult from SecurityLake. /// REST API Reference for CreateDataLakeOrganizationConfiguration Operation CreateDataLakeOrganizationConfigurationResponse EndCreateDataLakeOrganizationConfiguration(IAsyncResult asyncResult); #endregion #region CreateSubscriber /// /// 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. /// /// Container for the necessary parameters to execute the CreateSubscriber service method. /// /// The response from the CreateSubscriber service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for CreateSubscriber Operation CreateSubscriberResponse CreateSubscriber(CreateSubscriberRequest request); /// /// Initiates the asynchronous execution of the CreateSubscriber operation. /// /// /// Container for the necessary parameters to execute the CreateSubscriber operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateSubscriber /// operation. /// REST API Reference for CreateSubscriber Operation IAsyncResult BeginCreateSubscriber(CreateSubscriberRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the CreateSubscriber operation. /// /// /// The IAsyncResult returned by the call to BeginCreateSubscriber. /// /// Returns a CreateSubscriberResult from SecurityLake. /// REST API Reference for CreateSubscriber Operation CreateSubscriberResponse EndCreateSubscriber(IAsyncResult asyncResult); #endregion #region CreateSubscriberNotification /// /// 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. /// /// Container for the necessary parameters to execute the CreateSubscriberNotification service method. /// /// The response from the CreateSubscriberNotification service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for CreateSubscriberNotification Operation CreateSubscriberNotificationResponse CreateSubscriberNotification(CreateSubscriberNotificationRequest request); /// /// Initiates the asynchronous execution of the CreateSubscriberNotification operation. /// /// /// Container for the necessary parameters to execute the CreateSubscriberNotification operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateSubscriberNotification /// operation. /// REST API Reference for CreateSubscriberNotification Operation IAsyncResult BeginCreateSubscriberNotification(CreateSubscriberNotificationRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the CreateSubscriberNotification operation. /// /// /// The IAsyncResult returned by the call to BeginCreateSubscriberNotification. /// /// Returns a CreateSubscriberNotificationResult from SecurityLake. /// REST API Reference for CreateSubscriberNotification Operation CreateSubscriberNotificationResponse EndCreateSubscriberNotification(IAsyncResult asyncResult); #endregion #region DeleteAwsLogSource /// /// 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. /// /// /// Container for the necessary parameters to execute the DeleteAwsLogSource service method. /// /// The response from the DeleteAwsLogSource service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for DeleteAwsLogSource Operation DeleteAwsLogSourceResponse DeleteAwsLogSource(DeleteAwsLogSourceRequest request); /// /// Initiates the asynchronous execution of the DeleteAwsLogSource operation. /// /// /// Container for the necessary parameters to execute the DeleteAwsLogSource operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteAwsLogSource /// operation. /// REST API Reference for DeleteAwsLogSource Operation IAsyncResult BeginDeleteAwsLogSource(DeleteAwsLogSourceRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the DeleteAwsLogSource operation. /// /// /// The IAsyncResult returned by the call to BeginDeleteAwsLogSource. /// /// Returns a DeleteAwsLogSourceResult from SecurityLake. /// REST API Reference for DeleteAwsLogSource Operation DeleteAwsLogSourceResponse EndDeleteAwsLogSource(IAsyncResult asyncResult); #endregion #region DeleteCustomLogSource /// /// Removes a custom log source from Amazon Security Lake, to stop sending data from the /// custom source to Security Lake. /// /// Container for the necessary parameters to execute the DeleteCustomLogSource service method. /// /// The response from the DeleteCustomLogSource service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for DeleteCustomLogSource Operation DeleteCustomLogSourceResponse DeleteCustomLogSource(DeleteCustomLogSourceRequest request); /// /// Initiates the asynchronous execution of the DeleteCustomLogSource operation. /// /// /// Container for the necessary parameters to execute the DeleteCustomLogSource operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteCustomLogSource /// operation. /// REST API Reference for DeleteCustomLogSource Operation IAsyncResult BeginDeleteCustomLogSource(DeleteCustomLogSourceRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the DeleteCustomLogSource operation. /// /// /// The IAsyncResult returned by the call to BeginDeleteCustomLogSource. /// /// Returns a DeleteCustomLogSourceResult from SecurityLake. /// REST API Reference for DeleteCustomLogSource Operation DeleteCustomLogSourceResponse EndDeleteCustomLogSource(IAsyncResult asyncResult); #endregion #region DeleteDataLake /// /// 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. /// /// /// Container for the necessary parameters to execute the DeleteDataLake service method. /// /// The response from the DeleteDataLake service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for DeleteDataLake Operation DeleteDataLakeResponse DeleteDataLake(DeleteDataLakeRequest request); /// /// Initiates the asynchronous execution of the DeleteDataLake operation. /// /// /// Container for the necessary parameters to execute the DeleteDataLake operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteDataLake /// operation. /// REST API Reference for DeleteDataLake Operation IAsyncResult BeginDeleteDataLake(DeleteDataLakeRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the DeleteDataLake operation. /// /// /// The IAsyncResult returned by the call to BeginDeleteDataLake. /// /// Returns a DeleteDataLakeResult from SecurityLake. /// REST API Reference for DeleteDataLake Operation DeleteDataLakeResponse EndDeleteDataLake(IAsyncResult asyncResult); #endregion #region DeleteDataLakeExceptionSubscription /// /// Deletes the specified notification subscription in Amazon Security Lake for the organization /// you specify. /// /// Container for the necessary parameters to execute the DeleteDataLakeExceptionSubscription service method. /// /// The response from the DeleteDataLakeExceptionSubscription service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for DeleteDataLakeExceptionSubscription Operation DeleteDataLakeExceptionSubscriptionResponse DeleteDataLakeExceptionSubscription(DeleteDataLakeExceptionSubscriptionRequest request); /// /// Initiates the asynchronous execution of the DeleteDataLakeExceptionSubscription operation. /// /// /// Container for the necessary parameters to execute the DeleteDataLakeExceptionSubscription operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteDataLakeExceptionSubscription /// operation. /// REST API Reference for DeleteDataLakeExceptionSubscription Operation IAsyncResult BeginDeleteDataLakeExceptionSubscription(DeleteDataLakeExceptionSubscriptionRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the DeleteDataLakeExceptionSubscription operation. /// /// /// The IAsyncResult returned by the call to BeginDeleteDataLakeExceptionSubscription. /// /// Returns a DeleteDataLakeExceptionSubscriptionResult from SecurityLake. /// REST API Reference for DeleteDataLakeExceptionSubscription Operation DeleteDataLakeExceptionSubscriptionResponse EndDeleteDataLakeExceptionSubscription(IAsyncResult asyncResult); #endregion #region DeleteDataLakeOrganizationConfiguration /// /// 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. /// /// Container for the necessary parameters to execute the DeleteDataLakeOrganizationConfiguration service method. /// /// The response from the DeleteDataLakeOrganizationConfiguration service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for DeleteDataLakeOrganizationConfiguration Operation DeleteDataLakeOrganizationConfigurationResponse DeleteDataLakeOrganizationConfiguration(DeleteDataLakeOrganizationConfigurationRequest request); /// /// Initiates the asynchronous execution of the DeleteDataLakeOrganizationConfiguration operation. /// /// /// Container for the necessary parameters to execute the DeleteDataLakeOrganizationConfiguration operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteDataLakeOrganizationConfiguration /// operation. /// REST API Reference for DeleteDataLakeOrganizationConfiguration Operation IAsyncResult BeginDeleteDataLakeOrganizationConfiguration(DeleteDataLakeOrganizationConfigurationRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the DeleteDataLakeOrganizationConfiguration operation. /// /// /// The IAsyncResult returned by the call to BeginDeleteDataLakeOrganizationConfiguration. /// /// Returns a DeleteDataLakeOrganizationConfigurationResult from SecurityLake. /// REST API Reference for DeleteDataLakeOrganizationConfiguration Operation DeleteDataLakeOrganizationConfigurationResponse EndDeleteDataLakeOrganizationConfiguration(IAsyncResult asyncResult); #endregion #region DeleteSubscriber /// /// 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. /// /// Container for the necessary parameters to execute the DeleteSubscriber service method. /// /// The response from the DeleteSubscriber service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for DeleteSubscriber Operation DeleteSubscriberResponse DeleteSubscriber(DeleteSubscriberRequest request); /// /// Initiates the asynchronous execution of the DeleteSubscriber operation. /// /// /// Container for the necessary parameters to execute the DeleteSubscriber operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteSubscriber /// operation. /// REST API Reference for DeleteSubscriber Operation IAsyncResult BeginDeleteSubscriber(DeleteSubscriberRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the DeleteSubscriber operation. /// /// /// The IAsyncResult returned by the call to BeginDeleteSubscriber. /// /// Returns a DeleteSubscriberResult from SecurityLake. /// REST API Reference for DeleteSubscriber Operation DeleteSubscriberResponse EndDeleteSubscriber(IAsyncResult asyncResult); #endregion #region DeleteSubscriberNotification /// /// Deletes the specified notification subscription in Amazon Security Lake for the organization /// you specify. /// /// Container for the necessary parameters to execute the DeleteSubscriberNotification service method. /// /// The response from the DeleteSubscriberNotification service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for DeleteSubscriberNotification Operation DeleteSubscriberNotificationResponse DeleteSubscriberNotification(DeleteSubscriberNotificationRequest request); /// /// Initiates the asynchronous execution of the DeleteSubscriberNotification operation. /// /// /// Container for the necessary parameters to execute the DeleteSubscriberNotification operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteSubscriberNotification /// operation. /// REST API Reference for DeleteSubscriberNotification Operation IAsyncResult BeginDeleteSubscriberNotification(DeleteSubscriberNotificationRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the DeleteSubscriberNotification operation. /// /// /// The IAsyncResult returned by the call to BeginDeleteSubscriberNotification. /// /// Returns a DeleteSubscriberNotificationResult from SecurityLake. /// REST API Reference for DeleteSubscriberNotification Operation DeleteSubscriberNotificationResponse EndDeleteSubscriberNotification(IAsyncResult asyncResult); #endregion #region DeregisterDataLakeDelegatedAdministrator /// /// 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. /// /// Container for the necessary parameters to execute the DeregisterDataLakeDelegatedAdministrator service method. /// /// The response from the DeregisterDataLakeDelegatedAdministrator service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for DeregisterDataLakeDelegatedAdministrator Operation DeregisterDataLakeDelegatedAdministratorResponse DeregisterDataLakeDelegatedAdministrator(DeregisterDataLakeDelegatedAdministratorRequest request); /// /// Initiates the asynchronous execution of the DeregisterDataLakeDelegatedAdministrator operation. /// /// /// Container for the necessary parameters to execute the DeregisterDataLakeDelegatedAdministrator operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeregisterDataLakeDelegatedAdministrator /// operation. /// REST API Reference for DeregisterDataLakeDelegatedAdministrator Operation IAsyncResult BeginDeregisterDataLakeDelegatedAdministrator(DeregisterDataLakeDelegatedAdministratorRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the DeregisterDataLakeDelegatedAdministrator operation. /// /// /// The IAsyncResult returned by the call to BeginDeregisterDataLakeDelegatedAdministrator. /// /// Returns a DeregisterDataLakeDelegatedAdministratorResult from SecurityLake. /// REST API Reference for DeregisterDataLakeDelegatedAdministrator Operation DeregisterDataLakeDelegatedAdministratorResponse EndDeregisterDataLakeDelegatedAdministrator(IAsyncResult asyncResult); #endregion #region GetDataLakeExceptionSubscription /// /// Retrieves the details of exception notifications for the account in Amazon Security /// Lake. /// /// Container for the necessary parameters to execute the GetDataLakeExceptionSubscription service method. /// /// The response from the GetDataLakeExceptionSubscription service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for GetDataLakeExceptionSubscription Operation GetDataLakeExceptionSubscriptionResponse GetDataLakeExceptionSubscription(GetDataLakeExceptionSubscriptionRequest request); /// /// Initiates the asynchronous execution of the GetDataLakeExceptionSubscription operation. /// /// /// Container for the necessary parameters to execute the GetDataLakeExceptionSubscription operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDataLakeExceptionSubscription /// operation. /// REST API Reference for GetDataLakeExceptionSubscription Operation IAsyncResult BeginGetDataLakeExceptionSubscription(GetDataLakeExceptionSubscriptionRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the GetDataLakeExceptionSubscription operation. /// /// /// The IAsyncResult returned by the call to BeginGetDataLakeExceptionSubscription. /// /// Returns a GetDataLakeExceptionSubscriptionResult from SecurityLake. /// REST API Reference for GetDataLakeExceptionSubscription Operation GetDataLakeExceptionSubscriptionResponse EndGetDataLakeExceptionSubscription(IAsyncResult asyncResult); #endregion #region GetDataLakeOrganizationConfiguration /// /// 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. /// /// Container for the necessary parameters to execute the GetDataLakeOrganizationConfiguration service method. /// /// The response from the GetDataLakeOrganizationConfiguration service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for GetDataLakeOrganizationConfiguration Operation GetDataLakeOrganizationConfigurationResponse GetDataLakeOrganizationConfiguration(GetDataLakeOrganizationConfigurationRequest request); /// /// Initiates the asynchronous execution of the GetDataLakeOrganizationConfiguration operation. /// /// /// Container for the necessary parameters to execute the GetDataLakeOrganizationConfiguration operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDataLakeOrganizationConfiguration /// operation. /// REST API Reference for GetDataLakeOrganizationConfiguration Operation IAsyncResult BeginGetDataLakeOrganizationConfiguration(GetDataLakeOrganizationConfigurationRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the GetDataLakeOrganizationConfiguration operation. /// /// /// The IAsyncResult returned by the call to BeginGetDataLakeOrganizationConfiguration. /// /// Returns a GetDataLakeOrganizationConfigurationResult from SecurityLake. /// REST API Reference for GetDataLakeOrganizationConfiguration Operation GetDataLakeOrganizationConfigurationResponse EndGetDataLakeOrganizationConfiguration(IAsyncResult asyncResult); #endregion #region GetDataLakeSources /// /// 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. /// /// Container for the necessary parameters to execute the GetDataLakeSources service method. /// /// The response from the GetDataLakeSources service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for GetDataLakeSources Operation GetDataLakeSourcesResponse GetDataLakeSources(GetDataLakeSourcesRequest request); /// /// Initiates the asynchronous execution of the GetDataLakeSources operation. /// /// /// Container for the necessary parameters to execute the GetDataLakeSources operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDataLakeSources /// operation. /// REST API Reference for GetDataLakeSources Operation IAsyncResult BeginGetDataLakeSources(GetDataLakeSourcesRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the GetDataLakeSources operation. /// /// /// The IAsyncResult returned by the call to BeginGetDataLakeSources. /// /// Returns a GetDataLakeSourcesResult from SecurityLake. /// REST API Reference for GetDataLakeSources Operation GetDataLakeSourcesResponse EndGetDataLakeSources(IAsyncResult asyncResult); #endregion #region GetSubscriber /// /// Retrieves the subscription information for the specified subscription ID. You can /// get information about a specific subscriber. /// /// Container for the necessary parameters to execute the GetSubscriber service method. /// /// The response from the GetSubscriber service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for GetSubscriber Operation GetSubscriberResponse GetSubscriber(GetSubscriberRequest request); /// /// Initiates the asynchronous execution of the GetSubscriber operation. /// /// /// Container for the necessary parameters to execute the GetSubscriber operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetSubscriber /// operation. /// REST API Reference for GetSubscriber Operation IAsyncResult BeginGetSubscriber(GetSubscriberRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the GetSubscriber operation. /// /// /// The IAsyncResult returned by the call to BeginGetSubscriber. /// /// Returns a GetSubscriberResult from SecurityLake. /// REST API Reference for GetSubscriber Operation GetSubscriberResponse EndGetSubscriber(IAsyncResult asyncResult); #endregion #region ListDataLakeExceptions /// /// Lists the Amazon Security Lake exceptions that you can use to find the source of problems /// and fix them. /// /// Container for the necessary parameters to execute the ListDataLakeExceptions service method. /// /// The response from the ListDataLakeExceptions service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for ListDataLakeExceptions Operation ListDataLakeExceptionsResponse ListDataLakeExceptions(ListDataLakeExceptionsRequest request); /// /// Initiates the asynchronous execution of the ListDataLakeExceptions operation. /// /// /// Container for the necessary parameters to execute the ListDataLakeExceptions operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListDataLakeExceptions /// operation. /// REST API Reference for ListDataLakeExceptions Operation IAsyncResult BeginListDataLakeExceptions(ListDataLakeExceptionsRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the ListDataLakeExceptions operation. /// /// /// The IAsyncResult returned by the call to BeginListDataLakeExceptions. /// /// Returns a ListDataLakeExceptionsResult from SecurityLake. /// REST API Reference for ListDataLakeExceptions Operation ListDataLakeExceptionsResponse EndListDataLakeExceptions(IAsyncResult asyncResult); #endregion #region ListDataLakes /// /// 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. /// /// Container for the necessary parameters to execute the ListDataLakes service method. /// /// The response from the ListDataLakes service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for ListDataLakes Operation ListDataLakesResponse ListDataLakes(ListDataLakesRequest request); /// /// Initiates the asynchronous execution of the ListDataLakes operation. /// /// /// Container for the necessary parameters to execute the ListDataLakes operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListDataLakes /// operation. /// REST API Reference for ListDataLakes Operation IAsyncResult BeginListDataLakes(ListDataLakesRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the ListDataLakes operation. /// /// /// The IAsyncResult returned by the call to BeginListDataLakes. /// /// Returns a ListDataLakesResult from SecurityLake. /// REST API Reference for ListDataLakes Operation ListDataLakesResponse EndListDataLakes(IAsyncResult asyncResult); #endregion #region ListLogSources /// /// Retrieves the log sources in the current Amazon Web Services Region. /// /// Container for the necessary parameters to execute the ListLogSources service method. /// /// The response from the ListLogSources service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for ListLogSources Operation ListLogSourcesResponse ListLogSources(ListLogSourcesRequest request); /// /// Initiates the asynchronous execution of the ListLogSources operation. /// /// /// Container for the necessary parameters to execute the ListLogSources operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListLogSources /// operation. /// REST API Reference for ListLogSources Operation IAsyncResult BeginListLogSources(ListLogSourcesRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the ListLogSources operation. /// /// /// The IAsyncResult returned by the call to BeginListLogSources. /// /// Returns a ListLogSourcesResult from SecurityLake. /// REST API Reference for ListLogSources Operation ListLogSourcesResponse EndListLogSources(IAsyncResult asyncResult); #endregion #region ListSubscribers /// /// 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. /// /// Container for the necessary parameters to execute the ListSubscribers service method. /// /// The response from the ListSubscribers service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for ListSubscribers Operation ListSubscribersResponse ListSubscribers(ListSubscribersRequest request); /// /// Initiates the asynchronous execution of the ListSubscribers operation. /// /// /// Container for the necessary parameters to execute the ListSubscribers operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListSubscribers /// operation. /// REST API Reference for ListSubscribers Operation IAsyncResult BeginListSubscribers(ListSubscribersRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the ListSubscribers operation. /// /// /// The IAsyncResult returned by the call to BeginListSubscribers. /// /// Returns a ListSubscribersResult from SecurityLake. /// REST API Reference for ListSubscribers Operation ListSubscribersResponse EndListSubscribers(IAsyncResult asyncResult); #endregion #region ListTagsForResource /// /// 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. /// /// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// The response from the ListTagsForResource service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for ListTagsForResource Operation ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request); /// /// Initiates the asynchronous execution of the ListTagsForResource operation. /// /// /// Container for the necessary parameters to execute the ListTagsForResource operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTagsForResource /// operation. /// REST API Reference for ListTagsForResource Operation IAsyncResult BeginListTagsForResource(ListTagsForResourceRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the ListTagsForResource operation. /// /// /// The IAsyncResult returned by the call to BeginListTagsForResource. /// /// Returns a ListTagsForResourceResult from SecurityLake. /// REST API Reference for ListTagsForResource Operation ListTagsForResourceResponse EndListTagsForResource(IAsyncResult asyncResult); #endregion #region RegisterDataLakeDelegatedAdministrator /// /// 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. /// /// Container for the necessary parameters to execute the RegisterDataLakeDelegatedAdministrator service method. /// /// The response from the RegisterDataLakeDelegatedAdministrator service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for RegisterDataLakeDelegatedAdministrator Operation RegisterDataLakeDelegatedAdministratorResponse RegisterDataLakeDelegatedAdministrator(RegisterDataLakeDelegatedAdministratorRequest request); /// /// Initiates the asynchronous execution of the RegisterDataLakeDelegatedAdministrator operation. /// /// /// Container for the necessary parameters to execute the RegisterDataLakeDelegatedAdministrator operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRegisterDataLakeDelegatedAdministrator /// operation. /// REST API Reference for RegisterDataLakeDelegatedAdministrator Operation IAsyncResult BeginRegisterDataLakeDelegatedAdministrator(RegisterDataLakeDelegatedAdministratorRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the RegisterDataLakeDelegatedAdministrator operation. /// /// /// The IAsyncResult returned by the call to BeginRegisterDataLakeDelegatedAdministrator. /// /// Returns a RegisterDataLakeDelegatedAdministratorResult from SecurityLake. /// REST API Reference for RegisterDataLakeDelegatedAdministrator Operation RegisterDataLakeDelegatedAdministratorResponse EndRegisterDataLakeDelegatedAdministrator(IAsyncResult asyncResult); #endregion #region TagResource /// /// 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. /// /// Container for the necessary parameters to execute the TagResource service method. /// /// The response from the TagResource service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for TagResource Operation TagResourceResponse TagResource(TagResourceRequest request); /// /// Initiates the asynchronous execution of the TagResource operation. /// /// /// Container for the necessary parameters to execute the TagResource operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndTagResource /// operation. /// REST API Reference for TagResource Operation IAsyncResult BeginTagResource(TagResourceRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the TagResource operation. /// /// /// The IAsyncResult returned by the call to BeginTagResource. /// /// Returns a TagResourceResult from SecurityLake. /// REST API Reference for TagResource Operation TagResourceResponse EndTagResource(IAsyncResult asyncResult); #endregion #region UntagResource /// /// 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. /// /// Container for the necessary parameters to execute the UntagResource service method. /// /// The response from the UntagResource service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for UntagResource Operation UntagResourceResponse UntagResource(UntagResourceRequest request); /// /// Initiates the asynchronous execution of the UntagResource operation. /// /// /// Container for the necessary parameters to execute the UntagResource operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUntagResource /// operation. /// REST API Reference for UntagResource Operation IAsyncResult BeginUntagResource(UntagResourceRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the UntagResource operation. /// /// /// The IAsyncResult returned by the call to BeginUntagResource. /// /// Returns a UntagResourceResult from SecurityLake. /// REST API Reference for UntagResource Operation UntagResourceResponse EndUntagResource(IAsyncResult asyncResult); #endregion #region UpdateDataLake /// /// 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. /// /// Container for the necessary parameters to execute the UpdateDataLake service method. /// /// The response from the UpdateDataLake service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for UpdateDataLake Operation UpdateDataLakeResponse UpdateDataLake(UpdateDataLakeRequest request); /// /// Initiates the asynchronous execution of the UpdateDataLake operation. /// /// /// Container for the necessary parameters to execute the UpdateDataLake operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateDataLake /// operation. /// REST API Reference for UpdateDataLake Operation IAsyncResult BeginUpdateDataLake(UpdateDataLakeRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the UpdateDataLake operation. /// /// /// The IAsyncResult returned by the call to BeginUpdateDataLake. /// /// Returns a UpdateDataLakeResult from SecurityLake. /// REST API Reference for UpdateDataLake Operation UpdateDataLakeResponse EndUpdateDataLake(IAsyncResult asyncResult); #endregion #region UpdateDataLakeExceptionSubscription /// /// Updates the specified notification subscription in Amazon Security Lake for the organization /// you specify. /// /// Container for the necessary parameters to execute the UpdateDataLakeExceptionSubscription service method. /// /// The response from the UpdateDataLakeExceptionSubscription service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for UpdateDataLakeExceptionSubscription Operation UpdateDataLakeExceptionSubscriptionResponse UpdateDataLakeExceptionSubscription(UpdateDataLakeExceptionSubscriptionRequest request); /// /// Initiates the asynchronous execution of the UpdateDataLakeExceptionSubscription operation. /// /// /// Container for the necessary parameters to execute the UpdateDataLakeExceptionSubscription operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateDataLakeExceptionSubscription /// operation. /// REST API Reference for UpdateDataLakeExceptionSubscription Operation IAsyncResult BeginUpdateDataLakeExceptionSubscription(UpdateDataLakeExceptionSubscriptionRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the UpdateDataLakeExceptionSubscription operation. /// /// /// The IAsyncResult returned by the call to BeginUpdateDataLakeExceptionSubscription. /// /// Returns a UpdateDataLakeExceptionSubscriptionResult from SecurityLake. /// REST API Reference for UpdateDataLakeExceptionSubscription Operation UpdateDataLakeExceptionSubscriptionResponse EndUpdateDataLakeExceptionSubscription(IAsyncResult asyncResult); #endregion #region UpdateSubscriber /// /// 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. /// /// Container for the necessary parameters to execute the UpdateSubscriber service method. /// /// The response from the UpdateSubscriber service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for UpdateSubscriber Operation UpdateSubscriberResponse UpdateSubscriber(UpdateSubscriberRequest request); /// /// Initiates the asynchronous execution of the UpdateSubscriber operation. /// /// /// Container for the necessary parameters to execute the UpdateSubscriber operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateSubscriber /// operation. /// REST API Reference for UpdateSubscriber Operation IAsyncResult BeginUpdateSubscriber(UpdateSubscriberRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the UpdateSubscriber operation. /// /// /// The IAsyncResult returned by the call to BeginUpdateSubscriber. /// /// Returns a UpdateSubscriberResult from SecurityLake. /// REST API Reference for UpdateSubscriber Operation UpdateSubscriberResponse EndUpdateSubscriber(IAsyncResult asyncResult); #endregion #region UpdateSubscriberNotification /// /// Updates an existing notification method for the subscription (SQS or HTTPs endpoint) /// or switches the notification subscription endpoint for a subscriber. /// /// Container for the necessary parameters to execute the UpdateSubscriberNotification service method. /// /// The response from the UpdateSubscriberNotification service method, as returned by SecurityLake. /// /// 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. /// /// /// The request is malformed or contains an error such as an invalid parameter value or /// a missing required parameter. /// /// /// 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. /// /// /// Internal service exceptions are sometimes caused by transient issues. Before you start /// troubleshooting, perform the operation again. /// /// /// The resource could not be found. /// /// /// The limit on the number of requests per second was exceeded. /// /// REST API Reference for UpdateSubscriberNotification Operation UpdateSubscriberNotificationResponse UpdateSubscriberNotification(UpdateSubscriberNotificationRequest request); /// /// Initiates the asynchronous execution of the UpdateSubscriberNotification operation. /// /// /// Container for the necessary parameters to execute the UpdateSubscriberNotification operation on AmazonSecurityLakeClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateSubscriberNotification /// operation. /// REST API Reference for UpdateSubscriberNotification Operation IAsyncResult BeginUpdateSubscriberNotification(UpdateSubscriberNotificationRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the UpdateSubscriberNotification operation. /// /// /// The IAsyncResult returned by the call to BeginUpdateSubscriberNotification. /// /// Returns a UpdateSubscriberNotificationResult from SecurityLake. /// REST API Reference for UpdateSubscriberNotification Operation UpdateSubscriberNotificationResponse EndUpdateSubscriberNotification(IAsyncResult asyncResult); #endregion } }