/* * 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 lakeformation-2017-03-31.normal.json service model. */ using System; using System.Collections.Generic; using System.Net; using Amazon.LakeFormation.Model; using Amazon.LakeFormation.Model.Internal.MarshallTransformations; using Amazon.LakeFormation.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.LakeFormation { ///

/// Implementation for accessing LakeFormation /// /// Lake Formation /// /// Defines the public endpoint for the Lake Formation service. /// ///

public partial class AmazonLakeFormationClient : AmazonServiceClient, IAmazonLakeFormation { private static IServiceMetadata serviceMetadata = new AmazonLakeFormationMetadata(); #if BCL45 || AWS_ASYNC_ENUMERABLES_API private ILakeFormationPaginatorFactory _paginators; ///

/// Paginators for the service ///

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

/// Constructs AmazonLakeFormationClient 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 AmazonLakeFormationClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonLakeFormationConfig()) { } ///


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

/// ///

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


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

/// ///

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

/// Constructs AmazonLakeFormationClient with AWS Credentials ///

/// AWS Credentials public AmazonLakeFormationClient(AWSCredentials credentials) : this(credentials, new AmazonLakeFormationConfig()) { } ///

/// Constructs AmazonLakeFormationClient with AWS Credentials ///

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

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

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

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

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

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

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

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

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

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

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

/// Constructs AmazonLakeFormationClient 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 AmazonLakeFormationClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonLakeFormationConfig{RegionEndpoint = region}) { } ///

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

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonLakeFormationClient Configuration Object public AmazonLakeFormationClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonLakeFormationConfig 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 AmazonLakeFormationEndpointResolver()); } ///

/// 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 AddLFTagsToResource ///

/// Attaches one or more LF-tags to an existing resource. ///

/// Container for the necessary parameters to execute the AddLFTagsToResource service method. /// /// The response from the AddLFTagsToResource service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// Two processes are trying to modify a resource simultaneously. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for AddLFTagsToResource Operation public virtual AddLFTagsToResourceResponse AddLFTagsToResource(AddLFTagsToResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddLFTagsToResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = AddLFTagsToResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AddLFTagsToResource operation. ///

/// /// Container for the necessary parameters to execute the AddLFTagsToResource operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAddLFTagsToResource /// operation. /// REST API Reference for AddLFTagsToResource Operation public virtual IAsyncResult BeginAddLFTagsToResource(AddLFTagsToResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AddLFTagsToResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = AddLFTagsToResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AddLFTagsToResource operation. ///

/// /// The IAsyncResult returned by the call to BeginAddLFTagsToResource. /// /// Returns a AddLFTagsToResourceResult from LakeFormation. /// REST API Reference for AddLFTagsToResource Operation public virtual AddLFTagsToResourceResponse EndAddLFTagsToResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region AssumeDecoratedRoleWithSAML ///

/// Allows a caller to assume an IAM role decorated as the SAML user specified in the /// SAML assertion included in the request. This decoration allows Lake Formation to enforce /// access policies against the SAML users and groups. This API operation requires SAML /// federation setup in the caller’s account as it can only be called with valid SAML /// assertions. Lake Formation does not scope down the permission of the assumed role. /// All permissions attached to the role via the SAML federation setup will be included /// in the role session. /// /// /// /// This decorated role is expected to access data in Amazon S3 by getting temporary /// access from Lake Formation which is authorized via the virtual API GetDataAccess. /// Therefore, all SAML roles that can be assumed via AssumeDecoratedRoleWithSAML /// must at a minimum include lakeformation:GetDataAccess in their role policies. /// A typical IAM policy attached to such a role would look as follows: /// ///

/// Container for the necessary parameters to execute the AssumeDecoratedRoleWithSAML service method. /// /// The response from the AssumeDecoratedRoleWithSAML service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for AssumeDecoratedRoleWithSAML Operation public virtual AssumeDecoratedRoleWithSAMLResponse AssumeDecoratedRoleWithSAML(AssumeDecoratedRoleWithSAMLRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssumeDecoratedRoleWithSAMLRequestMarshaller.Instance; options.ResponseUnmarshaller = AssumeDecoratedRoleWithSAMLResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AssumeDecoratedRoleWithSAML operation. ///

/// /// Container for the necessary parameters to execute the AssumeDecoratedRoleWithSAML operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssumeDecoratedRoleWithSAML /// operation. /// REST API Reference for AssumeDecoratedRoleWithSAML Operation public virtual IAsyncResult BeginAssumeDecoratedRoleWithSAML(AssumeDecoratedRoleWithSAMLRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AssumeDecoratedRoleWithSAMLRequestMarshaller.Instance; options.ResponseUnmarshaller = AssumeDecoratedRoleWithSAMLResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AssumeDecoratedRoleWithSAML operation. ///

/// /// The IAsyncResult returned by the call to BeginAssumeDecoratedRoleWithSAML. /// /// Returns a AssumeDecoratedRoleWithSAMLResult from LakeFormation. /// REST API Reference for AssumeDecoratedRoleWithSAML Operation public virtual AssumeDecoratedRoleWithSAMLResponse EndAssumeDecoratedRoleWithSAML(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region BatchGrantPermissions ///

/// Batch operation to grant permissions to the principal. ///

/// Container for the necessary parameters to execute the BatchGrantPermissions service method. /// /// The response from the BatchGrantPermissions service method, as returned by LakeFormation. /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for BatchGrantPermissions Operation public virtual BatchGrantPermissionsResponse BatchGrantPermissions(BatchGrantPermissionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = BatchGrantPermissionsRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchGrantPermissionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the BatchGrantPermissions operation. ///

/// /// Container for the necessary parameters to execute the BatchGrantPermissions operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndBatchGrantPermissions /// operation. /// REST API Reference for BatchGrantPermissions Operation public virtual IAsyncResult BeginBatchGrantPermissions(BatchGrantPermissionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = BatchGrantPermissionsRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchGrantPermissionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the BatchGrantPermissions operation. ///

/// /// The IAsyncResult returned by the call to BeginBatchGrantPermissions. /// /// Returns a BatchGrantPermissionsResult from LakeFormation. /// REST API Reference for BatchGrantPermissions Operation public virtual BatchGrantPermissionsResponse EndBatchGrantPermissions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region BatchRevokePermissions ///

/// Batch operation to revoke permissions from the principal. ///

/// Container for the necessary parameters to execute the BatchRevokePermissions service method. /// /// The response from the BatchRevokePermissions service method, as returned by LakeFormation. /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for BatchRevokePermissions Operation public virtual BatchRevokePermissionsResponse BatchRevokePermissions(BatchRevokePermissionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = BatchRevokePermissionsRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchRevokePermissionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the BatchRevokePermissions operation. ///

/// /// Container for the necessary parameters to execute the BatchRevokePermissions operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndBatchRevokePermissions /// operation. /// REST API Reference for BatchRevokePermissions Operation public virtual IAsyncResult BeginBatchRevokePermissions(BatchRevokePermissionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = BatchRevokePermissionsRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchRevokePermissionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the BatchRevokePermissions operation. ///

/// /// The IAsyncResult returned by the call to BeginBatchRevokePermissions. /// /// Returns a BatchRevokePermissionsResult from LakeFormation. /// REST API Reference for BatchRevokePermissions Operation public virtual BatchRevokePermissionsResponse EndBatchRevokePermissions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CancelTransaction ///

/// Attempts to cancel the specified transaction. Returns an exception if the transaction /// was previously committed. ///

/// Container for the necessary parameters to execute the CancelTransaction service method. /// /// The response from the CancelTransaction service method, as returned by LakeFormation. /// /// Two processes are trying to modify a resource simultaneously. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// /// Contains details about an error related to a transaction commit that was in progress. /// /// /// Contains details about an error where the specified transaction has already been committed /// and cannot be used for UpdateTableObjects. /// /// REST API Reference for CancelTransaction Operation public virtual CancelTransactionResponse CancelTransaction(CancelTransactionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelTransactionRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelTransactionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CancelTransaction operation. ///

/// /// Container for the necessary parameters to execute the CancelTransaction operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelTransaction /// operation. /// REST API Reference for CancelTransaction Operation public virtual IAsyncResult BeginCancelTransaction(CancelTransactionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CancelTransactionRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelTransactionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CancelTransaction operation. ///

/// /// The IAsyncResult returned by the call to BeginCancelTransaction. /// /// Returns a CancelTransactionResult from LakeFormation. /// REST API Reference for CancelTransaction Operation public virtual CancelTransactionResponse EndCancelTransaction(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CommitTransaction ///

/// Attempts to commit the specified transaction. Returns an exception if the transaction /// was previously aborted. This API action is idempotent if called multiple times for /// the same transaction. ///

/// Container for the necessary parameters to execute the CommitTransaction service method. /// /// The response from the CommitTransaction service method, as returned by LakeFormation. /// /// Two processes are trying to modify a resource simultaneously. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// /// Contains details about an error related to a transaction that was cancelled. /// /// REST API Reference for CommitTransaction Operation public virtual CommitTransactionResponse CommitTransaction(CommitTransactionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CommitTransactionRequestMarshaller.Instance; options.ResponseUnmarshaller = CommitTransactionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CommitTransaction operation. ///

/// /// Container for the necessary parameters to execute the CommitTransaction operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCommitTransaction /// operation. /// REST API Reference for CommitTransaction Operation public virtual IAsyncResult BeginCommitTransaction(CommitTransactionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CommitTransactionRequestMarshaller.Instance; options.ResponseUnmarshaller = CommitTransactionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CommitTransaction operation. ///

/// /// The IAsyncResult returned by the call to BeginCommitTransaction. /// /// Returns a CommitTransactionResult from LakeFormation. /// REST API Reference for CommitTransaction Operation public virtual CommitTransactionResponse EndCommitTransaction(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateDataCellsFilter ///

/// Creates a data cell filter to allow one to grant access to certain columns on certain /// rows. ///

/// Container for the necessary parameters to execute the CreateDataCellsFilter service method. /// /// The response from the CreateDataCellsFilter service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// A resource to be created or added already exists. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// /// A resource numerical limit was exceeded. /// /// REST API Reference for CreateDataCellsFilter Operation public virtual CreateDataCellsFilterResponse CreateDataCellsFilter(CreateDataCellsFilterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDataCellsFilterRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDataCellsFilterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateDataCellsFilter operation. ///

/// /// Container for the necessary parameters to execute the CreateDataCellsFilter operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateDataCellsFilter /// operation. /// REST API Reference for CreateDataCellsFilter Operation public virtual IAsyncResult BeginCreateDataCellsFilter(CreateDataCellsFilterRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDataCellsFilterRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDataCellsFilterResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateDataCellsFilter operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateDataCellsFilter. /// /// Returns a CreateDataCellsFilterResult from LakeFormation. /// REST API Reference for CreateDataCellsFilter Operation public virtual CreateDataCellsFilterResponse EndCreateDataCellsFilter(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateLFTag ///

/// Creates an LF-tag with the specified name and values. ///

/// Container for the necessary parameters to execute the CreateLFTag service method. /// /// The response from the CreateLFTag service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// /// A resource numerical limit was exceeded. /// /// REST API Reference for CreateLFTag Operation public virtual CreateLFTagResponse CreateLFTag(CreateLFTagRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLFTagRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLFTagResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateLFTag operation. ///

/// /// Container for the necessary parameters to execute the CreateLFTag operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateLFTag /// operation. /// REST API Reference for CreateLFTag Operation public virtual IAsyncResult BeginCreateLFTag(CreateLFTagRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLFTagRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLFTagResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateLFTag operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateLFTag. /// /// Returns a CreateLFTagResult from LakeFormation. /// REST API Reference for CreateLFTag Operation public virtual CreateLFTagResponse EndCreateLFTag(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteDataCellsFilter ///

/// Deletes a data cell filter. ///

/// Container for the necessary parameters to execute the DeleteDataCellsFilter service method. /// /// The response from the DeleteDataCellsFilter service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for DeleteDataCellsFilter Operation public virtual DeleteDataCellsFilterResponse DeleteDataCellsFilter(DeleteDataCellsFilterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDataCellsFilterRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDataCellsFilterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteDataCellsFilter operation. ///

/// /// Container for the necessary parameters to execute the DeleteDataCellsFilter operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteDataCellsFilter /// operation. /// REST API Reference for DeleteDataCellsFilter Operation public virtual IAsyncResult BeginDeleteDataCellsFilter(DeleteDataCellsFilterRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDataCellsFilterRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDataCellsFilterResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteDataCellsFilter operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteDataCellsFilter. /// /// Returns a DeleteDataCellsFilterResult from LakeFormation. /// REST API Reference for DeleteDataCellsFilter Operation public virtual DeleteDataCellsFilterResponse EndDeleteDataCellsFilter(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteLFTag ///

/// Deletes the specified LF-tag given a key name. If the input parameter tag key was /// not found, then the operation will throw an exception. When you delete an LF-tag, /// the LFTagPolicy attached to the LF-tag becomes invalid. If the deleted /// LF-tag was still assigned to any resource, the tag policy attach to the deleted LF-tag /// will no longer be applied to the resource. ///

/// Container for the necessary parameters to execute the DeleteLFTag service method. /// /// The response from the DeleteLFTag service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for DeleteLFTag Operation public virtual DeleteLFTagResponse DeleteLFTag(DeleteLFTagRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLFTagRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLFTagResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteLFTag operation. ///

/// /// Container for the necessary parameters to execute the DeleteLFTag operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteLFTag /// operation. /// REST API Reference for DeleteLFTag Operation public virtual IAsyncResult BeginDeleteLFTag(DeleteLFTagRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLFTagRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLFTagResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteLFTag operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteLFTag. /// /// Returns a DeleteLFTagResult from LakeFormation. /// REST API Reference for DeleteLFTag Operation public virtual DeleteLFTagResponse EndDeleteLFTag(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteObjectsOnCancel ///

/// For a specific governed table, provides a list of Amazon S3 objects that will be written /// during the current transaction and that can be automatically deleted if the transaction /// is canceled. Without this call, no Amazon S3 objects are automatically deleted when /// a transaction cancels. /// /// /// /// The Glue ETL library function write_dynamic_frame.from_catalog() includes /// an option to automatically call DeleteObjectsOnCancel before writes. /// For more information, see Rolling /// Back Amazon S3 Writes. /// ///

/// Container for the necessary parameters to execute the DeleteObjectsOnCancel service method. /// /// The response from the DeleteObjectsOnCancel service method, as returned by LakeFormation. /// /// Two processes are trying to modify a resource simultaneously. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// /// Contains details about an error related to a resource which is not ready for a transaction. /// /// /// Contains details about an error related to a transaction that was cancelled. /// /// /// Contains details about an error where the specified transaction has already been committed /// and cannot be used for UpdateTableObjects. /// /// REST API Reference for DeleteObjectsOnCancel Operation public virtual DeleteObjectsOnCancelResponse DeleteObjectsOnCancel(DeleteObjectsOnCancelRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteObjectsOnCancelRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteObjectsOnCancelResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteObjectsOnCancel operation. ///

/// /// Container for the necessary parameters to execute the DeleteObjectsOnCancel operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteObjectsOnCancel /// operation. /// REST API Reference for DeleteObjectsOnCancel Operation public virtual IAsyncResult BeginDeleteObjectsOnCancel(DeleteObjectsOnCancelRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteObjectsOnCancelRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteObjectsOnCancelResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteObjectsOnCancel operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteObjectsOnCancel. /// /// Returns a DeleteObjectsOnCancelResult from LakeFormation. /// REST API Reference for DeleteObjectsOnCancel Operation public virtual DeleteObjectsOnCancelResponse EndDeleteObjectsOnCancel(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeregisterResource ///

/// Deregisters the resource as managed by the Data Catalog. /// /// /// /// When you deregister a path, Lake Formation removes the path from the inline policy /// attached to your service-linked role. /// ///

/// Container for the necessary parameters to execute the DeregisterResource service method. /// /// The response from the DeregisterResource service method, as returned by LakeFormation. /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for DeregisterResource Operation public virtual DeregisterResourceResponse DeregisterResource(DeregisterResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeregisterResource operation. ///

/// /// Container for the necessary parameters to execute the DeregisterResource operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeregisterResource /// operation. /// REST API Reference for DeregisterResource Operation public virtual IAsyncResult BeginDeregisterResource(DeregisterResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeregisterResource operation. ///

/// /// The IAsyncResult returned by the call to BeginDeregisterResource. /// /// Returns a DeregisterResourceResult from LakeFormation. /// REST API Reference for DeregisterResource Operation public virtual DeregisterResourceResponse EndDeregisterResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeResource ///

/// Retrieves the current data access role for the given resource registered in Lake Formation. ///

/// Container for the necessary parameters to execute the DescribeResource service method. /// /// The response from the DescribeResource service method, as returned by LakeFormation. /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for DescribeResource Operation public virtual DescribeResourceResponse DescribeResource(DescribeResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeResource operation. ///

/// /// Container for the necessary parameters to execute the DescribeResource operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeResource /// operation. /// REST API Reference for DescribeResource Operation public virtual IAsyncResult BeginDescribeResource(DescribeResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeResource operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeResource. /// /// Returns a DescribeResourceResult from LakeFormation. /// REST API Reference for DescribeResource Operation public virtual DescribeResourceResponse EndDescribeResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeTransaction ///

/// Returns the details of a single transaction. ///

/// Container for the necessary parameters to execute the DescribeTransaction service method. /// /// The response from the DescribeTransaction service method, as returned by LakeFormation. /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for DescribeTransaction Operation public virtual DescribeTransactionResponse DescribeTransaction(DescribeTransactionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeTransactionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeTransactionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeTransaction operation. ///

/// /// Container for the necessary parameters to execute the DescribeTransaction operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTransaction /// operation. /// REST API Reference for DescribeTransaction Operation public virtual IAsyncResult BeginDescribeTransaction(DescribeTransactionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeTransactionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeTransactionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeTransaction operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeTransaction. /// /// Returns a DescribeTransactionResult from LakeFormation. /// REST API Reference for DescribeTransaction Operation public virtual DescribeTransactionResponse EndDescribeTransaction(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ExtendTransaction ///

/// Indicates to the service that the specified transaction is still active and should /// not be treated as idle and aborted. /// /// /// /// Write transactions that remain idle for a long period are automatically aborted unless /// explicitly extended. /// ///

/// Container for the necessary parameters to execute the ExtendTransaction service method. /// /// The response from the ExtendTransaction service method, as returned by LakeFormation. /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// /// Contains details about an error related to a transaction that was cancelled. /// /// /// Contains details about an error related to a transaction commit that was in progress. /// /// /// Contains details about an error where the specified transaction has already been committed /// and cannot be used for UpdateTableObjects. /// /// REST API Reference for ExtendTransaction Operation public virtual ExtendTransactionResponse ExtendTransaction(ExtendTransactionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ExtendTransactionRequestMarshaller.Instance; options.ResponseUnmarshaller = ExtendTransactionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ExtendTransaction operation. ///

/// /// Container for the necessary parameters to execute the ExtendTransaction operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndExtendTransaction /// operation. /// REST API Reference for ExtendTransaction Operation public virtual IAsyncResult BeginExtendTransaction(ExtendTransactionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ExtendTransactionRequestMarshaller.Instance; options.ResponseUnmarshaller = ExtendTransactionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ExtendTransaction operation. ///

/// /// The IAsyncResult returned by the call to BeginExtendTransaction. /// /// Returns a ExtendTransactionResult from LakeFormation. /// REST API Reference for ExtendTransaction Operation public virtual ExtendTransactionResponse EndExtendTransaction(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDataCellsFilter ///

/// Returns a data cells filter. ///

/// Container for the necessary parameters to execute the GetDataCellsFilter service method. /// /// The response from the GetDataCellsFilter service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for GetDataCellsFilter Operation public virtual GetDataCellsFilterResponse GetDataCellsFilter(GetDataCellsFilterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDataCellsFilterRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDataCellsFilterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetDataCellsFilter operation. ///

/// /// Container for the necessary parameters to execute the GetDataCellsFilter operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDataCellsFilter /// operation. /// REST API Reference for GetDataCellsFilter Operation public virtual IAsyncResult BeginGetDataCellsFilter(GetDataCellsFilterRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDataCellsFilterRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDataCellsFilterResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetDataCellsFilter operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDataCellsFilter. /// /// Returns a GetDataCellsFilterResult from LakeFormation. /// REST API Reference for GetDataCellsFilter Operation public virtual GetDataCellsFilterResponse EndGetDataCellsFilter(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDataLakeSettings ///

/// Retrieves the list of the data lake administrators of a Lake Formation-managed data /// lake. ///

/// Container for the necessary parameters to execute the GetDataLakeSettings service method. /// /// The response from the GetDataLakeSettings service method, as returned by LakeFormation. /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// REST API Reference for GetDataLakeSettings Operation public virtual GetDataLakeSettingsResponse GetDataLakeSettings(GetDataLakeSettingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDataLakeSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDataLakeSettingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetDataLakeSettings operation. ///

/// /// Container for the necessary parameters to execute the GetDataLakeSettings operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDataLakeSettings /// operation. /// REST API Reference for GetDataLakeSettings Operation public virtual IAsyncResult BeginGetDataLakeSettings(GetDataLakeSettingsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDataLakeSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDataLakeSettingsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetDataLakeSettings operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDataLakeSettings. /// /// Returns a GetDataLakeSettingsResult from LakeFormation. /// REST API Reference for GetDataLakeSettings Operation public virtual GetDataLakeSettingsResponse EndGetDataLakeSettings(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetEffectivePermissionsForPath ///

/// Returns the Lake Formation permissions for a specified table or database resource /// located at a path in Amazon S3. GetEffectivePermissionsForPath will not /// return databases and tables if the catalog is encrypted. ///

/// Container for the necessary parameters to execute the GetEffectivePermissionsForPath service method. /// /// The response from the GetEffectivePermissionsForPath service method, as returned by LakeFormation. /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for GetEffectivePermissionsForPath Operation public virtual GetEffectivePermissionsForPathResponse GetEffectivePermissionsForPath(GetEffectivePermissionsForPathRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetEffectivePermissionsForPathRequestMarshaller.Instance; options.ResponseUnmarshaller = GetEffectivePermissionsForPathResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetEffectivePermissionsForPath operation. ///

/// /// Container for the necessary parameters to execute the GetEffectivePermissionsForPath operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetEffectivePermissionsForPath /// operation. /// REST API Reference for GetEffectivePermissionsForPath Operation public virtual IAsyncResult BeginGetEffectivePermissionsForPath(GetEffectivePermissionsForPathRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetEffectivePermissionsForPathRequestMarshaller.Instance; options.ResponseUnmarshaller = GetEffectivePermissionsForPathResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetEffectivePermissionsForPath operation. ///

/// /// The IAsyncResult returned by the call to BeginGetEffectivePermissionsForPath. /// /// Returns a GetEffectivePermissionsForPathResult from LakeFormation. /// REST API Reference for GetEffectivePermissionsForPath Operation public virtual GetEffectivePermissionsForPathResponse EndGetEffectivePermissionsForPath(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLFTag ///

/// Returns an LF-tag definition. ///

/// Container for the necessary parameters to execute the GetLFTag service method. /// /// The response from the GetLFTag service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for GetLFTag Operation public virtual GetLFTagResponse GetLFTag(GetLFTagRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLFTagRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLFTagResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetLFTag operation. ///

/// /// Container for the necessary parameters to execute the GetLFTag operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetLFTag /// operation. /// REST API Reference for GetLFTag Operation public virtual IAsyncResult BeginGetLFTag(GetLFTagRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetLFTagRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLFTagResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetLFTag operation. ///

/// /// The IAsyncResult returned by the call to BeginGetLFTag. /// /// Returns a GetLFTagResult from LakeFormation. /// REST API Reference for GetLFTag Operation public virtual GetLFTagResponse EndGetLFTag(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetQueryState ///

/// Returns the state of a query previously submitted. Clients are expected to poll GetQueryState /// to monitor the current state of the planning before retrieving the work units. A query /// state is only visible to the principal that made the initial call to StartQueryPlanning. ///

/// Container for the necessary parameters to execute the GetQueryState service method. /// /// The response from the GetQueryState service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// REST API Reference for GetQueryState Operation public virtual GetQueryStateResponse GetQueryState(GetQueryStateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetQueryStateRequestMarshaller.Instance; options.ResponseUnmarshaller = GetQueryStateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetQueryState operation. ///

/// /// Container for the necessary parameters to execute the GetQueryState operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetQueryState /// operation. /// REST API Reference for GetQueryState Operation public virtual IAsyncResult BeginGetQueryState(GetQueryStateRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetQueryStateRequestMarshaller.Instance; options.ResponseUnmarshaller = GetQueryStateResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetQueryState operation. ///

/// /// The IAsyncResult returned by the call to BeginGetQueryState. /// /// Returns a GetQueryStateResult from LakeFormation. /// REST API Reference for GetQueryState Operation public virtual GetQueryStateResponse EndGetQueryState(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetQueryStatistics ///

/// Retrieves statistics on the planning and execution of a query. ///

/// Container for the necessary parameters to execute the GetQueryStatistics service method. /// /// The response from the GetQueryStatistics service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// Contains details about an error where the query request expired. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// Contains details about an error related to statistics not being ready. /// /// /// Contains details about an error where the query request was throttled. /// /// REST API Reference for GetQueryStatistics Operation public virtual GetQueryStatisticsResponse GetQueryStatistics(GetQueryStatisticsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetQueryStatisticsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetQueryStatisticsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetQueryStatistics operation. ///

/// /// Container for the necessary parameters to execute the GetQueryStatistics operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetQueryStatistics /// operation. /// REST API Reference for GetQueryStatistics Operation public virtual IAsyncResult BeginGetQueryStatistics(GetQueryStatisticsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetQueryStatisticsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetQueryStatisticsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetQueryStatistics operation. ///

/// /// The IAsyncResult returned by the call to BeginGetQueryStatistics. /// /// Returns a GetQueryStatisticsResult from LakeFormation. /// REST API Reference for GetQueryStatistics Operation public virtual GetQueryStatisticsResponse EndGetQueryStatistics(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetResourceLFTags ///

/// Returns the LF-tags applied to a resource. ///

/// Container for the necessary parameters to execute the GetResourceLFTags service method. /// /// The response from the GetResourceLFTags service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// A specified entity does not exist. /// /// /// An encryption operation failed. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for GetResourceLFTags Operation public virtual GetResourceLFTagsResponse GetResourceLFTags(GetResourceLFTagsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetResourceLFTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetResourceLFTagsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetResourceLFTags operation. ///

/// /// Container for the necessary parameters to execute the GetResourceLFTags operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetResourceLFTags /// operation. /// REST API Reference for GetResourceLFTags Operation public virtual IAsyncResult BeginGetResourceLFTags(GetResourceLFTagsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetResourceLFTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetResourceLFTagsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetResourceLFTags operation. ///

/// /// The IAsyncResult returned by the call to BeginGetResourceLFTags. /// /// Returns a GetResourceLFTagsResult from LakeFormation. /// REST API Reference for GetResourceLFTags Operation public virtual GetResourceLFTagsResponse EndGetResourceLFTags(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetTableObjects ///

/// Returns the set of Amazon S3 objects that make up the specified governed table. A /// transaction ID or timestamp can be specified for time-travel queries. ///

/// Container for the necessary parameters to execute the GetTableObjects service method. /// /// The response from the GetTableObjects service method, as returned by LakeFormation. /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// /// Contains details about an error related to a resource which is not ready for a transaction. /// /// /// Contains details about an error related to a transaction that was cancelled. /// /// /// Contains details about an error where the specified transaction has already been committed /// and cannot be used for UpdateTableObjects. /// /// REST API Reference for GetTableObjects Operation public virtual GetTableObjectsResponse GetTableObjects(GetTableObjectsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetTableObjectsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetTableObjectsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetTableObjects operation. ///

/// /// Container for the necessary parameters to execute the GetTableObjects operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetTableObjects /// operation. /// REST API Reference for GetTableObjects Operation public virtual IAsyncResult BeginGetTableObjects(GetTableObjectsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetTableObjectsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetTableObjectsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetTableObjects operation. ///

/// /// The IAsyncResult returned by the call to BeginGetTableObjects. /// /// Returns a GetTableObjectsResult from LakeFormation. /// REST API Reference for GetTableObjects Operation public virtual GetTableObjectsResponse EndGetTableObjects(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetTemporaryGluePartitionCredentials ///

/// This API is identical to GetTemporaryTableCredentials except that this /// is used when the target Data Catalog resource is of type Partition. Lake Formation /// restricts the permission of the vended credentials with the same scope down policy /// which restricts access to a single Amazon S3 prefix. ///

/// Container for the necessary parameters to execute the GetTemporaryGluePartitionCredentials service method. /// /// The response from the GetTemporaryGluePartitionCredentials service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// /// The engine does not support filtering data based on the enforced permissions. For /// example, if you call the GetTemporaryGlueTableCredentials operation with /// SupportedPermissionType equal to ColumnPermission, but cell-level /// permissions exist on the table, this exception is thrown. /// /// REST API Reference for GetTemporaryGluePartitionCredentials Operation public virtual GetTemporaryGluePartitionCredentialsResponse GetTemporaryGluePartitionCredentials(GetTemporaryGluePartitionCredentialsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetTemporaryGluePartitionCredentialsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetTemporaryGluePartitionCredentialsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetTemporaryGluePartitionCredentials operation. ///

/// /// Container for the necessary parameters to execute the GetTemporaryGluePartitionCredentials operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetTemporaryGluePartitionCredentials /// operation. /// REST API Reference for GetTemporaryGluePartitionCredentials Operation public virtual IAsyncResult BeginGetTemporaryGluePartitionCredentials(GetTemporaryGluePartitionCredentialsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetTemporaryGluePartitionCredentialsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetTemporaryGluePartitionCredentialsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetTemporaryGluePartitionCredentials operation. ///

/// /// The IAsyncResult returned by the call to BeginGetTemporaryGluePartitionCredentials. /// /// Returns a GetTemporaryGluePartitionCredentialsResult from LakeFormation. /// REST API Reference for GetTemporaryGluePartitionCredentials Operation public virtual GetTemporaryGluePartitionCredentialsResponse EndGetTemporaryGluePartitionCredentials(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetTemporaryGlueTableCredentials ///

/// Allows a caller in a secure environment to assume a role with permission to access /// Amazon S3. In order to vend such credentials, Lake Formation assumes the role associated /// with a registered location, for example an Amazon S3 bucket, with a scope down policy /// which restricts the access to a single prefix. ///

/// Container for the necessary parameters to execute the GetTemporaryGlueTableCredentials service method. /// /// The response from the GetTemporaryGlueTableCredentials service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// /// The engine does not support filtering data based on the enforced permissions. For /// example, if you call the GetTemporaryGlueTableCredentials operation with /// SupportedPermissionType equal to ColumnPermission, but cell-level /// permissions exist on the table, this exception is thrown. /// /// REST API Reference for GetTemporaryGlueTableCredentials Operation public virtual GetTemporaryGlueTableCredentialsResponse GetTemporaryGlueTableCredentials(GetTemporaryGlueTableCredentialsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetTemporaryGlueTableCredentialsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetTemporaryGlueTableCredentialsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetTemporaryGlueTableCredentials operation. ///

/// /// Container for the necessary parameters to execute the GetTemporaryGlueTableCredentials operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetTemporaryGlueTableCredentials /// operation. /// REST API Reference for GetTemporaryGlueTableCredentials Operation public virtual IAsyncResult BeginGetTemporaryGlueTableCredentials(GetTemporaryGlueTableCredentialsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetTemporaryGlueTableCredentialsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetTemporaryGlueTableCredentialsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetTemporaryGlueTableCredentials operation. ///

/// /// The IAsyncResult returned by the call to BeginGetTemporaryGlueTableCredentials. /// /// Returns a GetTemporaryGlueTableCredentialsResult from LakeFormation. /// REST API Reference for GetTemporaryGlueTableCredentials Operation public virtual GetTemporaryGlueTableCredentialsResponse EndGetTemporaryGlueTableCredentials(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetWorkUnitResults ///

/// Returns the work units resulting from the query. Work units can be executed in any /// order and in parallel. ///

/// Container for the necessary parameters to execute the GetWorkUnitResults service method. /// /// The response from the GetWorkUnitResults service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// Contains details about an error where the query request expired. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// Contains details about an error where the query request was throttled. /// /// REST API Reference for GetWorkUnitResults Operation public virtual GetWorkUnitResultsResponse GetWorkUnitResults(GetWorkUnitResultsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetWorkUnitResultsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetWorkUnitResultsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetWorkUnitResults operation. ///

/// /// Container for the necessary parameters to execute the GetWorkUnitResults operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetWorkUnitResults /// operation. /// REST API Reference for GetWorkUnitResults Operation public virtual IAsyncResult BeginGetWorkUnitResults(GetWorkUnitResultsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetWorkUnitResultsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetWorkUnitResultsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetWorkUnitResults operation. ///

/// /// The IAsyncResult returned by the call to BeginGetWorkUnitResults. /// /// Returns a GetWorkUnitResultsResult from LakeFormation. /// REST API Reference for GetWorkUnitResults Operation public virtual GetWorkUnitResultsResponse EndGetWorkUnitResults(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetWorkUnits ///

/// Retrieves the work units generated by the StartQueryPlanning operation. ///

/// Container for the necessary parameters to execute the GetWorkUnits service method. /// /// The response from the GetWorkUnits service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// Contains details about an error where the query request expired. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// Contains details about an error related to work units not being ready. /// /// REST API Reference for GetWorkUnits Operation public virtual GetWorkUnitsResponse GetWorkUnits(GetWorkUnitsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetWorkUnitsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetWorkUnitsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetWorkUnits operation. ///

/// /// Container for the necessary parameters to execute the GetWorkUnits operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetWorkUnits /// operation. /// REST API Reference for GetWorkUnits Operation public virtual IAsyncResult BeginGetWorkUnits(GetWorkUnitsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetWorkUnitsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetWorkUnitsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetWorkUnits operation. ///

/// /// The IAsyncResult returned by the call to BeginGetWorkUnits. /// /// Returns a GetWorkUnitsResult from LakeFormation. /// REST API Reference for GetWorkUnits Operation public virtual GetWorkUnitsResponse EndGetWorkUnits(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GrantPermissions ///

/// Grants permissions to the principal to access metadata in the Data Catalog and data /// organized in underlying data storage such as Amazon S3. /// /// /// /// For information about permissions, see Security /// and Access Control to Metadata and Data. /// ///

/// Container for the necessary parameters to execute the GrantPermissions service method. /// /// The response from the GrantPermissions service method, as returned by LakeFormation. /// /// Two processes are trying to modify a resource simultaneously. /// /// /// A specified entity does not exist. /// /// /// The input provided was not valid. /// /// REST API Reference for GrantPermissions Operation public virtual GrantPermissionsResponse GrantPermissions(GrantPermissionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GrantPermissionsRequestMarshaller.Instance; options.ResponseUnmarshaller = GrantPermissionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GrantPermissions operation. ///

/// /// Container for the necessary parameters to execute the GrantPermissions operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGrantPermissions /// operation. /// REST API Reference for GrantPermissions Operation public virtual IAsyncResult BeginGrantPermissions(GrantPermissionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GrantPermissionsRequestMarshaller.Instance; options.ResponseUnmarshaller = GrantPermissionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GrantPermissions operation. ///

/// /// The IAsyncResult returned by the call to BeginGrantPermissions. /// /// Returns a GrantPermissionsResult from LakeFormation. /// REST API Reference for GrantPermissions Operation public virtual GrantPermissionsResponse EndGrantPermissions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListDataCellsFilter ///

/// Lists all the data cell filters on a table. ///

/// Container for the necessary parameters to execute the ListDataCellsFilter service method. /// /// The response from the ListDataCellsFilter service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for ListDataCellsFilter Operation public virtual ListDataCellsFilterResponse ListDataCellsFilter(ListDataCellsFilterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListDataCellsFilterRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDataCellsFilterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListDataCellsFilter operation. ///

/// /// Container for the necessary parameters to execute the ListDataCellsFilter operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListDataCellsFilter /// operation. /// REST API Reference for ListDataCellsFilter Operation public virtual IAsyncResult BeginListDataCellsFilter(ListDataCellsFilterRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListDataCellsFilterRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDataCellsFilterResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListDataCellsFilter operation. ///

/// /// The IAsyncResult returned by the call to BeginListDataCellsFilter. /// /// Returns a ListDataCellsFilterResult from LakeFormation. /// REST API Reference for ListDataCellsFilter Operation public virtual ListDataCellsFilterResponse EndListDataCellsFilter(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListLFTags ///

/// Lists LF-tags that the requester has permission to view. ///

/// Container for the necessary parameters to execute the ListLFTags service method. /// /// The response from the ListLFTags service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for ListLFTags Operation public virtual ListLFTagsResponse ListLFTags(ListLFTagsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListLFTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLFTagsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListLFTags operation. ///

/// /// Container for the necessary parameters to execute the ListLFTags operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListLFTags /// operation. /// REST API Reference for ListLFTags Operation public virtual IAsyncResult BeginListLFTags(ListLFTagsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListLFTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLFTagsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListLFTags operation. ///

/// /// The IAsyncResult returned by the call to BeginListLFTags. /// /// Returns a ListLFTagsResult from LakeFormation. /// REST API Reference for ListLFTags Operation public virtual ListLFTagsResponse EndListLFTags(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListPermissions ///

/// Returns a list of the principal permissions on the resource, filtered by the permissions /// of the caller. For example, if you are granted an ALTER permission, you are able to /// see only the principal permissions for ALTER. /// /// /// /// This operation returns only those permissions that have been explicitly granted. /// /// /// /// For information about permissions, see Security /// and Access Control to Metadata and Data. /// ///

/// Container for the necessary parameters to execute the ListPermissions service method. /// /// The response from the ListPermissions service method, as returned by LakeFormation. /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for ListPermissions Operation public virtual ListPermissionsResponse ListPermissions(ListPermissionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListPermissionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListPermissionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListPermissions operation. ///

/// /// Container for the necessary parameters to execute the ListPermissions operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListPermissions /// operation. /// REST API Reference for ListPermissions Operation public virtual IAsyncResult BeginListPermissions(ListPermissionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListPermissionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListPermissionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListPermissions operation. ///

/// /// The IAsyncResult returned by the call to BeginListPermissions. /// /// Returns a ListPermissionsResult from LakeFormation. /// REST API Reference for ListPermissions Operation public virtual ListPermissionsResponse EndListPermissions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListResources ///

/// Lists the resources registered to be managed by the Data Catalog. ///

/// Container for the necessary parameters to execute the ListResources service method. /// /// The response from the ListResources service method, as returned by LakeFormation. /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for ListResources Operation public virtual ListResourcesResponse ListResources(ListResourcesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListResourcesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListResourcesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListResources operation. ///

/// /// Container for the necessary parameters to execute the ListResources operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListResources /// operation. /// REST API Reference for ListResources Operation public virtual IAsyncResult BeginListResources(ListResourcesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListResourcesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListResourcesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListResources operation. ///

/// /// The IAsyncResult returned by the call to BeginListResources. /// /// Returns a ListResourcesResult from LakeFormation. /// REST API Reference for ListResources Operation public virtual ListResourcesResponse EndListResources(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTableStorageOptimizers ///

/// Returns the configuration of all storage optimizers associated with a specified table. ///

/// Container for the necessary parameters to execute the ListTableStorageOptimizers service method. /// /// The response from the ListTableStorageOptimizers service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// REST API Reference for ListTableStorageOptimizers Operation public virtual ListTableStorageOptimizersResponse ListTableStorageOptimizers(ListTableStorageOptimizersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTableStorageOptimizersRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTableStorageOptimizersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListTableStorageOptimizers operation. ///

/// /// Container for the necessary parameters to execute the ListTableStorageOptimizers operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTableStorageOptimizers /// operation. /// REST API Reference for ListTableStorageOptimizers Operation public virtual IAsyncResult BeginListTableStorageOptimizers(ListTableStorageOptimizersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListTableStorageOptimizersRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTableStorageOptimizersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListTableStorageOptimizers operation. ///

/// /// The IAsyncResult returned by the call to BeginListTableStorageOptimizers. /// /// Returns a ListTableStorageOptimizersResult from LakeFormation. /// REST API Reference for ListTableStorageOptimizers Operation public virtual ListTableStorageOptimizersResponse EndListTableStorageOptimizers(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTransactions ///

/// Returns metadata about transactions and their status. To prevent the response from /// growing indefinitely, only uncommitted transactions and those available for time-travel /// queries are returned. /// /// /// /// This operation can help you identify uncommitted transactions or to get information /// about transactions. /// ///

/// Container for the necessary parameters to execute the ListTransactions service method. /// /// The response from the ListTransactions service method, as returned by LakeFormation. /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for ListTransactions Operation public virtual ListTransactionsResponse ListTransactions(ListTransactionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTransactionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTransactionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListTransactions operation. ///

/// /// Container for the necessary parameters to execute the ListTransactions operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTransactions /// operation. /// REST API Reference for ListTransactions Operation public virtual IAsyncResult BeginListTransactions(ListTransactionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListTransactionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTransactionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListTransactions operation. ///

/// /// The IAsyncResult returned by the call to BeginListTransactions. /// /// Returns a ListTransactionsResult from LakeFormation. /// REST API Reference for ListTransactions Operation public virtual ListTransactionsResponse EndListTransactions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region PutDataLakeSettings ///

/// Sets the list of data lake administrators who have admin privileges on all resources /// managed by Lake Formation. For more information on admin privileges, see Granting /// Lake Formation Permissions. /// /// /// /// This API replaces the current list of data lake admins with the new list being passed. /// To add an admin, fetch the current list and add the new admin to that list and pass /// that list in this API. /// ///

/// Container for the necessary parameters to execute the PutDataLakeSettings service method. /// /// The response from the PutDataLakeSettings service method, as returned by LakeFormation. /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// REST API Reference for PutDataLakeSettings Operation public virtual PutDataLakeSettingsResponse PutDataLakeSettings(PutDataLakeSettingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutDataLakeSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = PutDataLakeSettingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the PutDataLakeSettings operation. ///

/// /// Container for the necessary parameters to execute the PutDataLakeSettings operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutDataLakeSettings /// operation. /// REST API Reference for PutDataLakeSettings Operation public virtual IAsyncResult BeginPutDataLakeSettings(PutDataLakeSettingsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = PutDataLakeSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = PutDataLakeSettingsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the PutDataLakeSettings operation. ///

/// /// The IAsyncResult returned by the call to BeginPutDataLakeSettings. /// /// Returns a PutDataLakeSettingsResult from LakeFormation. /// REST API Reference for PutDataLakeSettings Operation public virtual PutDataLakeSettingsResponse EndPutDataLakeSettings(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RegisterResource ///

/// Registers the resource as managed by the Data Catalog. /// /// /// /// To add or update data, Lake Formation needs read/write access to the chosen Amazon /// S3 path. Choose a role that you know has permission to do this, or choose the AWSServiceRoleForLakeFormationDataAccess /// service-linked role. When you register the first Amazon S3 path, the service-linked /// role and a new inline policy are created on your behalf. Lake Formation adds the first /// path to the inline policy and attaches it to the service-linked role. When you register /// subsequent paths, Lake Formation adds the path to the existing policy. /// /// /// /// The following request registers a new location and gives Lake Formation permission /// to use the service-linked role to access that location. /// /// /// /// ResourceArn = arn:aws:s3:::my-bucket UseServiceLinkedRole = true /// /// /// /// If UseServiceLinkedRole is not set to true, you must provide or set the /// RoleArn: /// /// /// /// arn:aws:iam::12345:role/my-data-access-role /// ///

/// Container for the necessary parameters to execute the RegisterResource service method. /// /// The response from the RegisterResource service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// A resource to be created or added already exists. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// /// A resource numerical limit was exceeded. /// /// REST API Reference for RegisterResource Operation public virtual RegisterResourceResponse RegisterResource(RegisterResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RegisterResource operation. ///

/// /// Container for the necessary parameters to execute the RegisterResource operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRegisterResource /// operation. /// REST API Reference for RegisterResource Operation public virtual IAsyncResult BeginRegisterResource(RegisterResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RegisterResource operation. ///

/// /// The IAsyncResult returned by the call to BeginRegisterResource. /// /// Returns a RegisterResourceResult from LakeFormation. /// REST API Reference for RegisterResource Operation public virtual RegisterResourceResponse EndRegisterResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RemoveLFTagsFromResource ///

/// Removes an LF-tag from the resource. Only database, table, or tableWithColumns resource /// are allowed. To tag columns, use the column inclusion list in tableWithColumns /// to specify column input. ///

/// Container for the necessary parameters to execute the RemoveLFTagsFromResource service method. /// /// The response from the RemoveLFTagsFromResource service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// Two processes are trying to modify a resource simultaneously. /// /// /// A specified entity does not exist. /// /// /// An encryption operation failed. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for RemoveLFTagsFromResource Operation public virtual RemoveLFTagsFromResourceResponse RemoveLFTagsFromResource(RemoveLFTagsFromResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveLFTagsFromResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveLFTagsFromResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RemoveLFTagsFromResource operation. ///

/// /// Container for the necessary parameters to execute the RemoveLFTagsFromResource operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRemoveLFTagsFromResource /// operation. /// REST API Reference for RemoveLFTagsFromResource Operation public virtual IAsyncResult BeginRemoveLFTagsFromResource(RemoveLFTagsFromResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveLFTagsFromResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveLFTagsFromResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RemoveLFTagsFromResource operation. ///

/// /// The IAsyncResult returned by the call to BeginRemoveLFTagsFromResource. /// /// Returns a RemoveLFTagsFromResourceResult from LakeFormation. /// REST API Reference for RemoveLFTagsFromResource Operation public virtual RemoveLFTagsFromResourceResponse EndRemoveLFTagsFromResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RevokePermissions ///

/// Revokes permissions to the principal to access metadata in the Data Catalog and data /// organized in underlying data storage such as Amazon S3. ///

/// Container for the necessary parameters to execute the RevokePermissions service method. /// /// The response from the RevokePermissions service method, as returned by LakeFormation. /// /// Two processes are trying to modify a resource simultaneously. /// /// /// A specified entity does not exist. /// /// /// The input provided was not valid. /// /// REST API Reference for RevokePermissions Operation public virtual RevokePermissionsResponse RevokePermissions(RevokePermissionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RevokePermissionsRequestMarshaller.Instance; options.ResponseUnmarshaller = RevokePermissionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RevokePermissions operation. ///

/// /// Container for the necessary parameters to execute the RevokePermissions operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRevokePermissions /// operation. /// REST API Reference for RevokePermissions Operation public virtual IAsyncResult BeginRevokePermissions(RevokePermissionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RevokePermissionsRequestMarshaller.Instance; options.ResponseUnmarshaller = RevokePermissionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RevokePermissions operation. ///

/// /// The IAsyncResult returned by the call to BeginRevokePermissions. /// /// Returns a RevokePermissionsResult from LakeFormation. /// REST API Reference for RevokePermissions Operation public virtual RevokePermissionsResponse EndRevokePermissions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region SearchDatabasesByLFTags ///

/// This operation allows a search on DATABASE resources by TagCondition. /// This operation is used by admins who want to grant user permissions on certain TagConditions. /// Before making a grant, the admin can use SearchDatabasesByTags to find /// all resources where the given TagConditions are valid to verify whether /// the returned resources can be shared. ///

/// Container for the necessary parameters to execute the SearchDatabasesByLFTags service method. /// /// The response from the SearchDatabasesByLFTags service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// A specified entity does not exist. /// /// /// An encryption operation failed. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for SearchDatabasesByLFTags Operation public virtual SearchDatabasesByLFTagsResponse SearchDatabasesByLFTags(SearchDatabasesByLFTagsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = SearchDatabasesByLFTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = SearchDatabasesByLFTagsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the SearchDatabasesByLFTags operation. ///

/// /// Container for the necessary parameters to execute the SearchDatabasesByLFTags operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSearchDatabasesByLFTags /// operation. /// REST API Reference for SearchDatabasesByLFTags Operation public virtual IAsyncResult BeginSearchDatabasesByLFTags(SearchDatabasesByLFTagsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = SearchDatabasesByLFTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = SearchDatabasesByLFTagsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the SearchDatabasesByLFTags operation. ///

/// /// The IAsyncResult returned by the call to BeginSearchDatabasesByLFTags. /// /// Returns a SearchDatabasesByLFTagsResult from LakeFormation. /// REST API Reference for SearchDatabasesByLFTags Operation public virtual SearchDatabasesByLFTagsResponse EndSearchDatabasesByLFTags(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region SearchTablesByLFTags ///

/// This operation allows a search on TABLE resources by LFTags. /// This will be used by admins who want to grant user permissions on certain LF-tags. /// Before making a grant, the admin can use SearchTablesByLFTags to find /// all resources where the given LFTags are valid to verify whether the /// returned resources can be shared. ///

/// Container for the necessary parameters to execute the SearchTablesByLFTags service method. /// /// The response from the SearchTablesByLFTags service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// A specified entity does not exist. /// /// /// An encryption operation failed. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for SearchTablesByLFTags Operation public virtual SearchTablesByLFTagsResponse SearchTablesByLFTags(SearchTablesByLFTagsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = SearchTablesByLFTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = SearchTablesByLFTagsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the SearchTablesByLFTags operation. ///

/// /// Container for the necessary parameters to execute the SearchTablesByLFTags operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSearchTablesByLFTags /// operation. /// REST API Reference for SearchTablesByLFTags Operation public virtual IAsyncResult BeginSearchTablesByLFTags(SearchTablesByLFTagsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = SearchTablesByLFTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = SearchTablesByLFTagsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the SearchTablesByLFTags operation. ///

/// /// The IAsyncResult returned by the call to BeginSearchTablesByLFTags. /// /// Returns a SearchTablesByLFTagsResult from LakeFormation. /// REST API Reference for SearchTablesByLFTags Operation public virtual SearchTablesByLFTagsResponse EndSearchTablesByLFTags(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartQueryPlanning ///

/// Submits a request to process a query statement. /// /// /// /// This operation generates work units that can be retrieved with the GetWorkUnits /// operation as soon as the query state is WORKUNITS_AVAILABLE or FINISHED. /// ///

/// Container for the necessary parameters to execute the StartQueryPlanning service method. /// /// The response from the StartQueryPlanning service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// Contains details about an error where the query request was throttled. /// /// REST API Reference for StartQueryPlanning Operation public virtual StartQueryPlanningResponse StartQueryPlanning(StartQueryPlanningRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartQueryPlanningRequestMarshaller.Instance; options.ResponseUnmarshaller = StartQueryPlanningResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartQueryPlanning operation. ///

/// /// Container for the necessary parameters to execute the StartQueryPlanning operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartQueryPlanning /// operation. /// REST API Reference for StartQueryPlanning Operation public virtual IAsyncResult BeginStartQueryPlanning(StartQueryPlanningRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartQueryPlanningRequestMarshaller.Instance; options.ResponseUnmarshaller = StartQueryPlanningResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartQueryPlanning operation. ///

/// /// The IAsyncResult returned by the call to BeginStartQueryPlanning. /// /// Returns a StartQueryPlanningResult from LakeFormation. /// REST API Reference for StartQueryPlanning Operation public virtual StartQueryPlanningResponse EndStartQueryPlanning(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartTransaction ///

/// Starts a new transaction and returns its transaction ID. Transaction IDs are opaque /// objects that you can use to identify a transaction. ///

/// Container for the necessary parameters to execute the StartTransaction service method. /// /// The response from the StartTransaction service method, as returned by LakeFormation. /// /// An internal service error occurred. /// /// /// The operation timed out. /// /// REST API Reference for StartTransaction Operation public virtual StartTransactionResponse StartTransaction(StartTransactionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartTransactionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartTransactionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartTransaction operation. ///

/// /// Container for the necessary parameters to execute the StartTransaction operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartTransaction /// operation. /// REST API Reference for StartTransaction Operation public virtual IAsyncResult BeginStartTransaction(StartTransactionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartTransactionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartTransactionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartTransaction operation. ///

/// /// The IAsyncResult returned by the call to BeginStartTransaction. /// /// Returns a StartTransactionResult from LakeFormation. /// REST API Reference for StartTransaction Operation public virtual StartTransactionResponse EndStartTransaction(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateDataCellsFilter ///

/// Updates a data cell filter. ///

/// Container for the necessary parameters to execute the UpdateDataCellsFilter service method. /// /// The response from the UpdateDataCellsFilter service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// Two processes are trying to modify a resource simultaneously. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for UpdateDataCellsFilter Operation public virtual UpdateDataCellsFilterResponse UpdateDataCellsFilter(UpdateDataCellsFilterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDataCellsFilterRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDataCellsFilterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateDataCellsFilter operation. ///

/// /// Container for the necessary parameters to execute the UpdateDataCellsFilter operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateDataCellsFilter /// operation. /// REST API Reference for UpdateDataCellsFilter Operation public virtual IAsyncResult BeginUpdateDataCellsFilter(UpdateDataCellsFilterRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDataCellsFilterRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDataCellsFilterResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateDataCellsFilter operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateDataCellsFilter. /// /// Returns a UpdateDataCellsFilterResult from LakeFormation. /// REST API Reference for UpdateDataCellsFilter Operation public virtual UpdateDataCellsFilterResponse EndUpdateDataCellsFilter(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateLFTag ///

/// Updates the list of possible values for the specified LF-tag key. If the LF-tag does /// not exist, the operation throws an EntityNotFoundException. The values in the delete /// key values will be deleted from list of possible values. If any value in the delete /// key values is attached to a resource, then API errors out with a 400 Exception - "Update /// not allowed". Untag the attribute before deleting the LF-tag key's value. ///

/// Container for the necessary parameters to execute the UpdateLFTag service method. /// /// The response from the UpdateLFTag service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// Two processes are trying to modify a resource simultaneously. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for UpdateLFTag Operation public virtual UpdateLFTagResponse UpdateLFTag(UpdateLFTagRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateLFTagRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateLFTagResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateLFTag operation. ///

/// /// Container for the necessary parameters to execute the UpdateLFTag operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateLFTag /// operation. /// REST API Reference for UpdateLFTag Operation public virtual IAsyncResult BeginUpdateLFTag(UpdateLFTagRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateLFTagRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateLFTagResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateLFTag operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateLFTag. /// /// Returns a UpdateLFTagResult from LakeFormation. /// REST API Reference for UpdateLFTag Operation public virtual UpdateLFTagResponse EndUpdateLFTag(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateResource ///

/// Updates the data access role used for vending access to the given (registered) resource /// in Lake Formation. ///

/// Container for the necessary parameters to execute the UpdateResource service method. /// /// The response from the UpdateResource service method, as returned by LakeFormation. /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// REST API Reference for UpdateResource Operation public virtual UpdateResourceResponse UpdateResource(UpdateResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateResource operation. ///

/// /// Container for the necessary parameters to execute the UpdateResource operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateResource /// operation. /// REST API Reference for UpdateResource Operation public virtual IAsyncResult BeginUpdateResource(UpdateResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateResource operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateResource. /// /// Returns a UpdateResourceResult from LakeFormation. /// REST API Reference for UpdateResource Operation public virtual UpdateResourceResponse EndUpdateResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateTableObjects ///

/// Updates the manifest of Amazon S3 objects that make up the specified governed table. ///

/// Container for the necessary parameters to execute the UpdateTableObjects service method. /// /// The response from the UpdateTableObjects service method, as returned by LakeFormation. /// /// Two processes are trying to modify a resource simultaneously. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// /// The operation timed out. /// /// /// Contains details about an error related to a resource which is not ready for a transaction. /// /// /// Contains details about an error related to a transaction that was cancelled. /// /// /// Contains details about an error related to a transaction commit that was in progress. /// /// /// Contains details about an error where the specified transaction has already been committed /// and cannot be used for UpdateTableObjects. /// /// REST API Reference for UpdateTableObjects Operation public virtual UpdateTableObjectsResponse UpdateTableObjects(UpdateTableObjectsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateTableObjectsRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateTableObjectsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateTableObjects operation. ///

/// /// Container for the necessary parameters to execute the UpdateTableObjects operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateTableObjects /// operation. /// REST API Reference for UpdateTableObjects Operation public virtual IAsyncResult BeginUpdateTableObjects(UpdateTableObjectsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateTableObjectsRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateTableObjectsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateTableObjects operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateTableObjects. /// /// Returns a UpdateTableObjectsResult from LakeFormation. /// REST API Reference for UpdateTableObjects Operation public virtual UpdateTableObjectsResponse EndUpdateTableObjects(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateTableStorageOptimizer ///

/// Updates the configuration of the storage optimizers for a table. ///

/// Container for the necessary parameters to execute the UpdateTableStorageOptimizer service method. /// /// The response from the UpdateTableStorageOptimizer service method, as returned by LakeFormation. /// /// Access to a resource was denied. /// /// /// A specified entity does not exist. /// /// /// An internal service error occurred. /// /// /// The input provided was not valid. /// /// REST API Reference for UpdateTableStorageOptimizer Operation public virtual UpdateTableStorageOptimizerResponse UpdateTableStorageOptimizer(UpdateTableStorageOptimizerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateTableStorageOptimizerRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateTableStorageOptimizerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateTableStorageOptimizer operation. ///

/// /// Container for the necessary parameters to execute the UpdateTableStorageOptimizer operation on AmazonLakeFormationClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateTableStorageOptimizer /// operation. /// REST API Reference for UpdateTableStorageOptimizer Operation public virtual IAsyncResult BeginUpdateTableStorageOptimizer(UpdateTableStorageOptimizerRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateTableStorageOptimizerRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateTableStorageOptimizerResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateTableStorageOptimizer operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateTableStorageOptimizer. /// /// Returns a UpdateTableStorageOptimizerResult from LakeFormation. /// REST API Reference for UpdateTableStorageOptimizer Operation public virtual UpdateTableStorageOptimizerResponse EndUpdateTableStorageOptimizer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }