/* * 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.Threading; using System.Threading.Tasks; 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 { ///

/// Paginators for the service ///

ISecurityLakePaginatorFactory Paginators { get; } #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); ///

/// Container for the necessary parameters to execute the CreateAwsLogSource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateAwsLogSourceAsync(CreateAwsLogSourceRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Container for the necessary parameters to execute the CreateCustomLogSource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateCustomLogSourceAsync(CreateCustomLogSourceRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Container for the necessary parameters to execute the CreateDataLake service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateDataLakeAsync(CreateDataLakeRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateDataLakeExceptionSubscriptionAsync(CreateDataLakeExceptionSubscriptionRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Container for the necessary parameters to execute the CreateDataLakeOrganizationConfiguration service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateDataLakeOrganizationConfigurationAsync(CreateDataLakeOrganizationConfigurationRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Container for the necessary parameters to execute the CreateSubscriber service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateSubscriberAsync(CreateSubscriberRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Container for the necessary parameters to execute the CreateSubscriberNotification service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateSubscriberNotificationAsync(CreateSubscriberNotificationRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Container for the necessary parameters to execute the DeleteAwsLogSource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteAwsLogSourceAsync(DeleteAwsLogSourceRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteCustomLogSourceAsync(DeleteCustomLogSourceRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Container for the necessary parameters to execute the DeleteDataLake service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteDataLakeAsync(DeleteDataLakeRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteDataLakeExceptionSubscriptionAsync(DeleteDataLakeExceptionSubscriptionRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Container for the necessary parameters to execute the DeleteDataLakeOrganizationConfiguration service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteDataLakeOrganizationConfigurationAsync(DeleteDataLakeOrganizationConfigurationRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Container for the necessary parameters to execute the DeleteSubscriber service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteSubscriberAsync(DeleteSubscriberRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteSubscriberNotificationAsync(DeleteSubscriberNotificationRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Container for the necessary parameters to execute the DeregisterDataLakeDelegatedAdministrator service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeregisterDataLakeDelegatedAdministratorAsync(DeregisterDataLakeDelegatedAdministratorRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Retrieves the details of exception notifications for the account in Amazon Security /// Lake. ///

/// Container for the necessary parameters to execute the GetDataLakeExceptionSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetDataLakeExceptionSubscriptionAsync(GetDataLakeExceptionSubscriptionRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Container for the necessary parameters to execute the GetDataLakeOrganizationConfiguration service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetDataLakeOrganizationConfigurationAsync(GetDataLakeOrganizationConfigurationRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetDataLakeSourcesAsync(GetDataLakeSourcesRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetSubscriberAsync(GetSubscriberRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListDataLakeExceptionsAsync(ListDataLakeExceptionsRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Container for the necessary parameters to execute the ListDataLakes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListDataLakesAsync(ListDataLakesRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Retrieves the log sources in the current Amazon Web Services Region. ///

/// Container for the necessary parameters to execute the ListLogSources service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListLogSourcesAsync(ListLogSourcesRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListSubscribersAsync(ListSubscribersRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListTagsForResourceAsync(ListTagsForResourceRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Container for the necessary parameters to execute the RegisterDataLakeDelegatedAdministrator service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task RegisterDataLakeDelegatedAdministratorAsync(RegisterDataLakeDelegatedAdministratorRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Container for the necessary parameters to execute the TagResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task TagResourceAsync(TagResourceRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// Container for the necessary parameters to execute the UntagResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UntagResourceAsync(UntagResourceRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateDataLakeAsync(UpdateDataLakeRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateDataLakeExceptionSubscriptionAsync(UpdateDataLakeExceptionSubscriptionRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateSubscriberAsync(UpdateSubscriberRequest request, CancellationToken cancellationToken = default(CancellationToken)); #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); ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateSubscriberNotificationAsync(UpdateSubscriberNotificationRequest request, CancellationToken cancellationToken = default(CancellationToken)); #endregion } }