/* * 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.Runtime.ExceptionServices; using System.Threading; using System.Threading.Tasks; using System.Collections.Generic; using System.Net; using Amazon.SecurityLake.Model; using Amazon.SecurityLake.Model.Internal.MarshallTransformations; using Amazon.SecurityLake.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.SecurityLake { ///

/// Implementation 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 class AmazonSecurityLakeClient : AmazonServiceClient, IAmazonSecurityLake { private static IServiceMetadata serviceMetadata = new AmazonSecurityLakeMetadata(); private ISecurityLakePaginatorFactory _paginators; ///

/// Paginators for the service ///

public ISecurityLakePaginatorFactory Paginators { get { if (this._paginators == null) { this._paginators = new SecurityLakePaginatorFactory(this); } return this._paginators; } } #region Constructors ///

/// Constructs AmazonSecurityLakeClient with the credentials loaded from the application's /// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance. /// /// Example App.config with credentials set. ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

public AmazonSecurityLakeClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonSecurityLakeConfig()) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The region to connect. public AmazonSecurityLakeClient(RegionEndpoint region) : base(FallbackCredentialsFactory.GetCredentials(), new AmazonSecurityLakeConfig{RegionEndpoint = region}) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The AmazonSecurityLakeClient Configuration Object public AmazonSecurityLakeClient(AmazonSecurityLakeConfig config) : base(FallbackCredentialsFactory.GetCredentials(config), config){} ///

/// Constructs AmazonSecurityLakeClient with AWS Credentials ///

/// AWS Credentials public AmazonSecurityLakeClient(AWSCredentials credentials) : this(credentials, new AmazonSecurityLakeConfig()) { } ///

/// Constructs AmazonSecurityLakeClient with AWS Credentials ///

/// AWS Credentials /// The region to connect. public AmazonSecurityLakeClient(AWSCredentials credentials, RegionEndpoint region) : this(credentials, new AmazonSecurityLakeConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonSecurityLakeClient with AWS Credentials and an /// AmazonSecurityLakeClient Configuration object. ///

/// AWS Credentials /// The AmazonSecurityLakeClient Configuration Object public AmazonSecurityLakeClient(AWSCredentials credentials, AmazonSecurityLakeConfig clientConfig) : base(credentials, clientConfig) { } ///

/// Constructs AmazonSecurityLakeClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key public AmazonSecurityLakeClient(string awsAccessKeyId, string awsSecretAccessKey) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonSecurityLakeConfig()) { } ///

/// Constructs AmazonSecurityLakeClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// The region to connect. public AmazonSecurityLakeClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonSecurityLakeConfig() {RegionEndpoint=region}) { } ///

/// Constructs AmazonSecurityLakeClient with AWS Access Key ID, AWS Secret Key and an /// AmazonSecurityLakeClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// The AmazonSecurityLakeClient Configuration Object public AmazonSecurityLakeClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonSecurityLakeConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, clientConfig) { } ///

/// Constructs AmazonSecurityLakeClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token public AmazonSecurityLakeClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonSecurityLakeConfig()) { } ///

/// Constructs AmazonSecurityLakeClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The region to connect. public AmazonSecurityLakeClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonSecurityLakeConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonSecurityLakeClient with AWS Access Key ID, AWS Secret Key and an /// AmazonSecurityLakeClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonSecurityLakeClient Configuration Object public AmazonSecurityLakeClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonSecurityLakeConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig) { } #endregion #region Overrides ///

/// Creates the signer for the service. ///

protected override AbstractAWSSigner CreateSigner() { return new AWS4Signer(); } ///

/// Customize the pipeline ///

/// protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline) { pipeline.RemoveHandler(); pipeline.AddHandlerAfter(new AmazonSecurityLakeEndpointResolver()); } ///

/// Capture metadata for the service. ///

protected override IServiceMetadata ServiceMetadata { get { return serviceMetadata; } } #endregion #region Dispose ///

/// Disposes the service client. ///

protected override void Dispose(bool disposing) { base.Dispose(disposing); } #endregion #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 public virtual CreateAwsLogSourceResponse CreateAwsLogSource(CreateAwsLogSourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAwsLogSourceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAwsLogSourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateAwsLogSourceAsync(CreateAwsLogSourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAwsLogSourceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAwsLogSourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual CreateCustomLogSourceResponse CreateCustomLogSource(CreateCustomLogSourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCustomLogSourceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCustomLogSourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateCustomLogSourceAsync(CreateCustomLogSourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCustomLogSourceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCustomLogSourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual CreateDataLakeResponse CreateDataLake(CreateDataLakeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDataLakeRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDataLakeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateDataLakeAsync(CreateDataLakeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDataLakeRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDataLakeResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual CreateDataLakeExceptionSubscriptionResponse CreateDataLakeExceptionSubscription(CreateDataLakeExceptionSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDataLakeExceptionSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDataLakeExceptionSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateDataLakeExceptionSubscriptionAsync(CreateDataLakeExceptionSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDataLakeExceptionSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDataLakeExceptionSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual CreateDataLakeOrganizationConfigurationResponse CreateDataLakeOrganizationConfiguration(CreateDataLakeOrganizationConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDataLakeOrganizationConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDataLakeOrganizationConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateDataLakeOrganizationConfigurationAsync(CreateDataLakeOrganizationConfigurationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDataLakeOrganizationConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDataLakeOrganizationConfigurationResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual CreateSubscriberResponse CreateSubscriber(CreateSubscriberRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSubscriberRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSubscriberResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateSubscriberAsync(CreateSubscriberRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSubscriberRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSubscriberResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual CreateSubscriberNotificationResponse CreateSubscriberNotification(CreateSubscriberNotificationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSubscriberNotificationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSubscriberNotificationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateSubscriberNotificationAsync(CreateSubscriberNotificationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSubscriberNotificationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSubscriberNotificationResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual DeleteAwsLogSourceResponse DeleteAwsLogSource(DeleteAwsLogSourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAwsLogSourceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAwsLogSourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task DeleteAwsLogSourceAsync(DeleteAwsLogSourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAwsLogSourceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAwsLogSourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual DeleteCustomLogSourceResponse DeleteCustomLogSource(DeleteCustomLogSourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCustomLogSourceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCustomLogSourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task DeleteCustomLogSourceAsync(DeleteCustomLogSourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCustomLogSourceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCustomLogSourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual DeleteDataLakeResponse DeleteDataLake(DeleteDataLakeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDataLakeRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDataLakeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task DeleteDataLakeAsync(DeleteDataLakeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDataLakeRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDataLakeResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual DeleteDataLakeExceptionSubscriptionResponse DeleteDataLakeExceptionSubscription(DeleteDataLakeExceptionSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDataLakeExceptionSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDataLakeExceptionSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task DeleteDataLakeExceptionSubscriptionAsync(DeleteDataLakeExceptionSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDataLakeExceptionSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDataLakeExceptionSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual DeleteDataLakeOrganizationConfigurationResponse DeleteDataLakeOrganizationConfiguration(DeleteDataLakeOrganizationConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDataLakeOrganizationConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDataLakeOrganizationConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task DeleteDataLakeOrganizationConfigurationAsync(DeleteDataLakeOrganizationConfigurationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDataLakeOrganizationConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDataLakeOrganizationConfigurationResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual DeleteSubscriberResponse DeleteSubscriber(DeleteSubscriberRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSubscriberRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSubscriberResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task DeleteSubscriberAsync(DeleteSubscriberRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSubscriberRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSubscriberResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual DeleteSubscriberNotificationResponse DeleteSubscriberNotification(DeleteSubscriberNotificationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSubscriberNotificationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSubscriberNotificationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task DeleteSubscriberNotificationAsync(DeleteSubscriberNotificationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSubscriberNotificationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSubscriberNotificationResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual DeregisterDataLakeDelegatedAdministratorResponse DeregisterDataLakeDelegatedAdministrator(DeregisterDataLakeDelegatedAdministratorRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterDataLakeDelegatedAdministratorRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterDataLakeDelegatedAdministratorResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task DeregisterDataLakeDelegatedAdministratorAsync(DeregisterDataLakeDelegatedAdministratorRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterDataLakeDelegatedAdministratorRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterDataLakeDelegatedAdministratorResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual GetDataLakeExceptionSubscriptionResponse GetDataLakeExceptionSubscription(GetDataLakeExceptionSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDataLakeExceptionSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDataLakeExceptionSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task GetDataLakeExceptionSubscriptionAsync(GetDataLakeExceptionSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetDataLakeExceptionSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDataLakeExceptionSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual GetDataLakeOrganizationConfigurationResponse GetDataLakeOrganizationConfiguration(GetDataLakeOrganizationConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDataLakeOrganizationConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDataLakeOrganizationConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task GetDataLakeOrganizationConfigurationAsync(GetDataLakeOrganizationConfigurationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetDataLakeOrganizationConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDataLakeOrganizationConfigurationResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual GetDataLakeSourcesResponse GetDataLakeSources(GetDataLakeSourcesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDataLakeSourcesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDataLakeSourcesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task GetDataLakeSourcesAsync(GetDataLakeSourcesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetDataLakeSourcesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDataLakeSourcesResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual GetSubscriberResponse GetSubscriber(GetSubscriberRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetSubscriberRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSubscriberResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task GetSubscriberAsync(GetSubscriberRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetSubscriberRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSubscriberResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual ListDataLakeExceptionsResponse ListDataLakeExceptions(ListDataLakeExceptionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListDataLakeExceptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDataLakeExceptionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task ListDataLakeExceptionsAsync(ListDataLakeExceptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListDataLakeExceptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDataLakeExceptionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual ListDataLakesResponse ListDataLakes(ListDataLakesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListDataLakesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDataLakesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task ListDataLakesAsync(ListDataLakesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListDataLakesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDataLakesResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual ListLogSourcesResponse ListLogSources(ListLogSourcesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListLogSourcesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLogSourcesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task ListLogSourcesAsync(ListLogSourcesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListLogSourcesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLogSourcesResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual ListSubscribersResponse ListSubscribers(ListSubscribersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListSubscribersRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSubscribersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task ListSubscribersAsync(ListSubscribersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListSubscribersRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSubscribersResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task ListTagsForResourceAsync(ListTagsForResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual RegisterDataLakeDelegatedAdministratorResponse RegisterDataLakeDelegatedAdministrator(RegisterDataLakeDelegatedAdministratorRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterDataLakeDelegatedAdministratorRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterDataLakeDelegatedAdministratorResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task RegisterDataLakeDelegatedAdministratorAsync(RegisterDataLakeDelegatedAdministratorRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterDataLakeDelegatedAdministratorRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterDataLakeDelegatedAdministratorResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual TagResourceResponse TagResource(TagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task TagResourceAsync(TagResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual UntagResourceResponse UntagResource(UntagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task UntagResourceAsync(UntagResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual UpdateDataLakeResponse UpdateDataLake(UpdateDataLakeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDataLakeRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDataLakeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task UpdateDataLakeAsync(UpdateDataLakeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDataLakeRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDataLakeResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual UpdateDataLakeExceptionSubscriptionResponse UpdateDataLakeExceptionSubscription(UpdateDataLakeExceptionSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDataLakeExceptionSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDataLakeExceptionSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task UpdateDataLakeExceptionSubscriptionAsync(UpdateDataLakeExceptionSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDataLakeExceptionSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDataLakeExceptionSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual UpdateSubscriberResponse UpdateSubscriber(UpdateSubscriberRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSubscriberRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSubscriberResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task UpdateSubscriberAsync(UpdateSubscriberRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSubscriberRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSubscriberResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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 public virtual UpdateSubscriberNotificationResponse UpdateSubscriberNotification(UpdateSubscriberNotificationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSubscriberNotificationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSubscriberNotificationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task UpdateSubscriberNotificationAsync(UpdateSubscriberNotificationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSubscriberNotificationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSubscriberNotificationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion } }