/* * 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 cleanrooms-2022-02-17.normal.json service model. */ using System; using System.Collections.Generic; using System.Net; using Amazon.CleanRooms.Model; using Amazon.CleanRooms.Model.Internal.MarshallTransformations; using Amazon.CleanRooms.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.CleanRooms { ///

/// Implementation for accessing CleanRooms /// /// Welcome to the Clean Rooms API Reference. /// /// /// /// Clean Rooms is an Amazon Web Services service that helps multiple parties to join /// their data together in a secure collaboration workspace. In the collaboration, members /// who can query and receive results can get insights into the collective datasets without /// either party getting access to the other party's raw data. /// /// /// /// To learn more about Clean Rooms concepts, procedures, and best practices, see the /// Clean /// Rooms User Guide. /// ///

public partial class AmazonCleanRoomsClient : AmazonServiceClient, IAmazonCleanRooms { private static IServiceMetadata serviceMetadata = new AmazonCleanRoomsMetadata(); #if BCL45 || AWS_ASYNC_ENUMERABLES_API private ICleanRoomsPaginatorFactory _paginators; ///

/// Paginators for the service ///

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

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


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

/// ///

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


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

/// ///

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

/// Constructs AmazonCleanRoomsClient with AWS Credentials ///

/// AWS Credentials public AmazonCleanRoomsClient(AWSCredentials credentials) : this(credentials, new AmazonCleanRoomsConfig()) { } ///

/// Constructs AmazonCleanRoomsClient with AWS Credentials ///

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Retrieves multiple schemas by their identifiers. ///

/// Container for the necessary parameters to execute the BatchGetSchema service method. /// /// The response from the BatchGetSchema service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for BatchGetSchema Operation public virtual BatchGetSchemaResponse BatchGetSchema(BatchGetSchemaRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = BatchGetSchemaRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchGetSchemaResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the BatchGetSchema operation on AmazonCleanRoomsClient. /// 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 EndBatchGetSchema /// operation. /// REST API Reference for BatchGetSchema Operation public virtual IAsyncResult BeginBatchGetSchema(BatchGetSchemaRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = BatchGetSchemaRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchGetSchemaResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginBatchGetSchema. /// /// Returns a BatchGetSchemaResult from CleanRooms. /// REST API Reference for BatchGetSchema Operation public virtual BatchGetSchemaResponse EndBatchGetSchema(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateCollaboration ///

/// Creates a new collaboration. ///

/// Container for the necessary parameters to execute the CreateCollaboration service method. /// /// The response from the CreateCollaboration service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request denied because service quota has been exceeded. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for CreateCollaboration Operation public virtual CreateCollaborationResponse CreateCollaboration(CreateCollaborationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCollaborationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCollaborationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateCollaboration operation on AmazonCleanRoomsClient. /// 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 EndCreateCollaboration /// operation. /// REST API Reference for CreateCollaboration Operation public virtual IAsyncResult BeginCreateCollaboration(CreateCollaborationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCollaborationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCollaborationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateCollaboration. /// /// Returns a CreateCollaborationResult from CleanRooms. /// REST API Reference for CreateCollaboration Operation public virtual CreateCollaborationResponse EndCreateCollaboration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateConfiguredTable ///

/// Creates a new configured table resource. ///

/// Container for the necessary parameters to execute the CreateConfiguredTable service method. /// /// The response from the CreateConfiguredTable service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Updating or deleting a resource can cause an inconsistent state. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request denied because service quota has been exceeded. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for CreateConfiguredTable Operation public virtual CreateConfiguredTableResponse CreateConfiguredTable(CreateConfiguredTableRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateConfiguredTableRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateConfiguredTableResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateConfiguredTable operation on AmazonCleanRoomsClient. /// 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 EndCreateConfiguredTable /// operation. /// REST API Reference for CreateConfiguredTable Operation public virtual IAsyncResult BeginCreateConfiguredTable(CreateConfiguredTableRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateConfiguredTableRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateConfiguredTableResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateConfiguredTable. /// /// Returns a CreateConfiguredTableResult from CleanRooms. /// REST API Reference for CreateConfiguredTable Operation public virtual CreateConfiguredTableResponse EndCreateConfiguredTable(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateConfiguredTableAnalysisRule ///

/// Creates a new analysis rule for a configured table. Currently, only one analysis rule /// can be created for a given configured table. ///

/// Container for the necessary parameters to execute the CreateConfiguredTableAnalysisRule service method. /// /// The response from the CreateConfiguredTableAnalysisRule service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Updating or deleting a resource can cause an inconsistent state. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for CreateConfiguredTableAnalysisRule Operation public virtual CreateConfiguredTableAnalysisRuleResponse CreateConfiguredTableAnalysisRule(CreateConfiguredTableAnalysisRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateConfiguredTableAnalysisRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateConfiguredTableAnalysisRuleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateConfiguredTableAnalysisRule operation on AmazonCleanRoomsClient. /// 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 EndCreateConfiguredTableAnalysisRule /// operation. /// REST API Reference for CreateConfiguredTableAnalysisRule Operation public virtual IAsyncResult BeginCreateConfiguredTableAnalysisRule(CreateConfiguredTableAnalysisRuleRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateConfiguredTableAnalysisRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateConfiguredTableAnalysisRuleResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateConfiguredTableAnalysisRule. /// /// Returns a CreateConfiguredTableAnalysisRuleResult from CleanRooms. /// REST API Reference for CreateConfiguredTableAnalysisRule Operation public virtual CreateConfiguredTableAnalysisRuleResponse EndCreateConfiguredTableAnalysisRule(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateConfiguredTableAssociation ///

/// Creates a configured table association. A configured table association links a configured /// table with a collaboration. ///

/// Container for the necessary parameters to execute the CreateConfiguredTableAssociation service method. /// /// The response from the CreateConfiguredTableAssociation service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Updating or deleting a resource can cause an inconsistent state. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request denied because service quota has been exceeded. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for CreateConfiguredTableAssociation Operation public virtual CreateConfiguredTableAssociationResponse CreateConfiguredTableAssociation(CreateConfiguredTableAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateConfiguredTableAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateConfiguredTableAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateConfiguredTableAssociation operation on AmazonCleanRoomsClient. /// 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 EndCreateConfiguredTableAssociation /// operation. /// REST API Reference for CreateConfiguredTableAssociation Operation public virtual IAsyncResult BeginCreateConfiguredTableAssociation(CreateConfiguredTableAssociationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateConfiguredTableAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateConfiguredTableAssociationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateConfiguredTableAssociation. /// /// Returns a CreateConfiguredTableAssociationResult from CleanRooms. /// REST API Reference for CreateConfiguredTableAssociation Operation public virtual CreateConfiguredTableAssociationResponse EndCreateConfiguredTableAssociation(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateMembership ///

/// Creates a membership for a specific collaboration identifier and joins the collaboration. ///

/// Container for the necessary parameters to execute the CreateMembership service method. /// /// The response from the CreateMembership service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Updating or deleting a resource can cause an inconsistent state. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request denied because service quota has been exceeded. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for CreateMembership Operation public virtual CreateMembershipResponse CreateMembership(CreateMembershipRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateMembershipRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateMembershipResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateMembership operation on AmazonCleanRoomsClient. /// 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 EndCreateMembership /// operation. /// REST API Reference for CreateMembership Operation public virtual IAsyncResult BeginCreateMembership(CreateMembershipRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateMembershipRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateMembershipResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateMembership. /// /// Returns a CreateMembershipResult from CleanRooms. /// REST API Reference for CreateMembership Operation public virtual CreateMembershipResponse EndCreateMembership(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteCollaboration ///

/// Deletes a collaboration. It can only be called by the collaboration owner. ///

/// Container for the necessary parameters to execute the DeleteCollaboration service method. /// /// The response from the DeleteCollaboration service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for DeleteCollaboration Operation public virtual DeleteCollaborationResponse DeleteCollaboration(DeleteCollaborationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCollaborationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCollaborationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteCollaboration operation on AmazonCleanRoomsClient. /// 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 EndDeleteCollaboration /// operation. /// REST API Reference for DeleteCollaboration Operation public virtual IAsyncResult BeginDeleteCollaboration(DeleteCollaborationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCollaborationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCollaborationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteCollaboration. /// /// Returns a DeleteCollaborationResult from CleanRooms. /// REST API Reference for DeleteCollaboration Operation public virtual DeleteCollaborationResponse EndDeleteCollaboration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteConfiguredTable ///

/// Deletes a configured table. ///

/// Container for the necessary parameters to execute the DeleteConfiguredTable service method. /// /// The response from the DeleteConfiguredTable service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Updating or deleting a resource can cause an inconsistent state. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for DeleteConfiguredTable Operation public virtual DeleteConfiguredTableResponse DeleteConfiguredTable(DeleteConfiguredTableRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteConfiguredTableRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteConfiguredTableResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteConfiguredTable operation on AmazonCleanRoomsClient. /// 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 EndDeleteConfiguredTable /// operation. /// REST API Reference for DeleteConfiguredTable Operation public virtual IAsyncResult BeginDeleteConfiguredTable(DeleteConfiguredTableRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteConfiguredTableRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteConfiguredTableResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteConfiguredTable. /// /// Returns a DeleteConfiguredTableResult from CleanRooms. /// REST API Reference for DeleteConfiguredTable Operation public virtual DeleteConfiguredTableResponse EndDeleteConfiguredTable(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteConfiguredTableAnalysisRule ///

/// Deletes a configured table analysis rule. ///

/// Container for the necessary parameters to execute the DeleteConfiguredTableAnalysisRule service method. /// /// The response from the DeleteConfiguredTableAnalysisRule service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Updating or deleting a resource can cause an inconsistent state. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for DeleteConfiguredTableAnalysisRule Operation public virtual DeleteConfiguredTableAnalysisRuleResponse DeleteConfiguredTableAnalysisRule(DeleteConfiguredTableAnalysisRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteConfiguredTableAnalysisRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteConfiguredTableAnalysisRuleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteConfiguredTableAnalysisRule operation on AmazonCleanRoomsClient. /// 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 EndDeleteConfiguredTableAnalysisRule /// operation. /// REST API Reference for DeleteConfiguredTableAnalysisRule Operation public virtual IAsyncResult BeginDeleteConfiguredTableAnalysisRule(DeleteConfiguredTableAnalysisRuleRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteConfiguredTableAnalysisRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteConfiguredTableAnalysisRuleResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteConfiguredTableAnalysisRule. /// /// Returns a DeleteConfiguredTableAnalysisRuleResult from CleanRooms. /// REST API Reference for DeleteConfiguredTableAnalysisRule Operation public virtual DeleteConfiguredTableAnalysisRuleResponse EndDeleteConfiguredTableAnalysisRule(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteConfiguredTableAssociation ///

/// Deletes a configured table association. ///

/// Container for the necessary parameters to execute the DeleteConfiguredTableAssociation service method. /// /// The response from the DeleteConfiguredTableAssociation service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Updating or deleting a resource can cause an inconsistent state. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for DeleteConfiguredTableAssociation Operation public virtual DeleteConfiguredTableAssociationResponse DeleteConfiguredTableAssociation(DeleteConfiguredTableAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteConfiguredTableAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteConfiguredTableAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteConfiguredTableAssociation operation on AmazonCleanRoomsClient. /// 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 EndDeleteConfiguredTableAssociation /// operation. /// REST API Reference for DeleteConfiguredTableAssociation Operation public virtual IAsyncResult BeginDeleteConfiguredTableAssociation(DeleteConfiguredTableAssociationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteConfiguredTableAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteConfiguredTableAssociationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteConfiguredTableAssociation. /// /// Returns a DeleteConfiguredTableAssociationResult from CleanRooms. /// REST API Reference for DeleteConfiguredTableAssociation Operation public virtual DeleteConfiguredTableAssociationResponse EndDeleteConfiguredTableAssociation(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteMember ///

/// Removes the specified member from a collaboration. The removed member is placed in /// the Removed status and can't interact with the collaboration. The removed member's /// data is inaccessible to active members of the collaboration. ///

/// Container for the necessary parameters to execute the DeleteMember service method. /// /// The response from the DeleteMember service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Updating or deleting a resource can cause an inconsistent state. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for DeleteMember Operation public virtual DeleteMemberResponse DeleteMember(DeleteMemberRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteMemberRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteMemberResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteMember operation on AmazonCleanRoomsClient. /// 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 EndDeleteMember /// operation. /// REST API Reference for DeleteMember Operation public virtual IAsyncResult BeginDeleteMember(DeleteMemberRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteMemberRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteMemberResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteMember. /// /// Returns a DeleteMemberResult from CleanRooms. /// REST API Reference for DeleteMember Operation public virtual DeleteMemberResponse EndDeleteMember(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteMembership ///

/// Deletes a specified membership. All resources under a membership must be deleted. ///

/// Container for the necessary parameters to execute the DeleteMembership service method. /// /// The response from the DeleteMembership service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Updating or deleting a resource can cause an inconsistent state. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for DeleteMembership Operation public virtual DeleteMembershipResponse DeleteMembership(DeleteMembershipRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteMembershipRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteMembershipResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteMembership operation on AmazonCleanRoomsClient. /// 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 EndDeleteMembership /// operation. /// REST API Reference for DeleteMembership Operation public virtual IAsyncResult BeginDeleteMembership(DeleteMembershipRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteMembershipRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteMembershipResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteMembership. /// /// Returns a DeleteMembershipResult from CleanRooms. /// REST API Reference for DeleteMembership Operation public virtual DeleteMembershipResponse EndDeleteMembership(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetCollaboration ///

/// Returns metadata about a collaboration. ///

/// Container for the necessary parameters to execute the GetCollaboration service method. /// /// The response from the GetCollaboration service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for GetCollaboration Operation public virtual GetCollaborationResponse GetCollaboration(GetCollaborationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCollaborationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCollaborationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetCollaboration operation on AmazonCleanRoomsClient. /// 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 EndGetCollaboration /// operation. /// REST API Reference for GetCollaboration Operation public virtual IAsyncResult BeginGetCollaboration(GetCollaborationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetCollaborationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCollaborationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetCollaboration. /// /// Returns a GetCollaborationResult from CleanRooms. /// REST API Reference for GetCollaboration Operation public virtual GetCollaborationResponse EndGetCollaboration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetConfiguredTable ///

/// Retrieves a configured table. ///

/// Container for the necessary parameters to execute the GetConfiguredTable service method. /// /// The response from the GetConfiguredTable service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for GetConfiguredTable Operation public virtual GetConfiguredTableResponse GetConfiguredTable(GetConfiguredTableRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetConfiguredTableRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConfiguredTableResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetConfiguredTable operation on AmazonCleanRoomsClient. /// 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 EndGetConfiguredTable /// operation. /// REST API Reference for GetConfiguredTable Operation public virtual IAsyncResult BeginGetConfiguredTable(GetConfiguredTableRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetConfiguredTableRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConfiguredTableResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetConfiguredTable. /// /// Returns a GetConfiguredTableResult from CleanRooms. /// REST API Reference for GetConfiguredTable Operation public virtual GetConfiguredTableResponse EndGetConfiguredTable(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetConfiguredTableAnalysisRule ///

/// Retrieves a configured table analysis rule. ///

/// Container for the necessary parameters to execute the GetConfiguredTableAnalysisRule service method. /// /// The response from the GetConfiguredTableAnalysisRule service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for GetConfiguredTableAnalysisRule Operation public virtual GetConfiguredTableAnalysisRuleResponse GetConfiguredTableAnalysisRule(GetConfiguredTableAnalysisRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetConfiguredTableAnalysisRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConfiguredTableAnalysisRuleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetConfiguredTableAnalysisRule operation on AmazonCleanRoomsClient. /// 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 EndGetConfiguredTableAnalysisRule /// operation. /// REST API Reference for GetConfiguredTableAnalysisRule Operation public virtual IAsyncResult BeginGetConfiguredTableAnalysisRule(GetConfiguredTableAnalysisRuleRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetConfiguredTableAnalysisRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConfiguredTableAnalysisRuleResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetConfiguredTableAnalysisRule. /// /// Returns a GetConfiguredTableAnalysisRuleResult from CleanRooms. /// REST API Reference for GetConfiguredTableAnalysisRule Operation public virtual GetConfiguredTableAnalysisRuleResponse EndGetConfiguredTableAnalysisRule(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetConfiguredTableAssociation ///

/// Retrieves a configured table association. ///

/// Container for the necessary parameters to execute the GetConfiguredTableAssociation service method. /// /// The response from the GetConfiguredTableAssociation service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for GetConfiguredTableAssociation Operation public virtual GetConfiguredTableAssociationResponse GetConfiguredTableAssociation(GetConfiguredTableAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetConfiguredTableAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConfiguredTableAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetConfiguredTableAssociation operation on AmazonCleanRoomsClient. /// 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 EndGetConfiguredTableAssociation /// operation. /// REST API Reference for GetConfiguredTableAssociation Operation public virtual IAsyncResult BeginGetConfiguredTableAssociation(GetConfiguredTableAssociationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetConfiguredTableAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConfiguredTableAssociationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetConfiguredTableAssociation. /// /// Returns a GetConfiguredTableAssociationResult from CleanRooms. /// REST API Reference for GetConfiguredTableAssociation Operation public virtual GetConfiguredTableAssociationResponse EndGetConfiguredTableAssociation(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetMembership ///

/// Retrieves a specified membership for an identifier. ///

/// Container for the necessary parameters to execute the GetMembership service method. /// /// The response from the GetMembership service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for GetMembership Operation public virtual GetMembershipResponse GetMembership(GetMembershipRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetMembershipRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMembershipResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetMembership operation on AmazonCleanRoomsClient. /// 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 EndGetMembership /// operation. /// REST API Reference for GetMembership Operation public virtual IAsyncResult BeginGetMembership(GetMembershipRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetMembershipRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMembershipResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetMembership. /// /// Returns a GetMembershipResult from CleanRooms. /// REST API Reference for GetMembership Operation public virtual GetMembershipResponse EndGetMembership(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetProtectedQuery ///

/// Returns query processing metadata. ///

/// Container for the necessary parameters to execute the GetProtectedQuery service method. /// /// The response from the GetProtectedQuery service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for GetProtectedQuery Operation public virtual GetProtectedQueryResponse GetProtectedQuery(GetProtectedQueryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetProtectedQueryRequestMarshaller.Instance; options.ResponseUnmarshaller = GetProtectedQueryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetProtectedQuery operation on AmazonCleanRoomsClient. /// 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 EndGetProtectedQuery /// operation. /// REST API Reference for GetProtectedQuery Operation public virtual IAsyncResult BeginGetProtectedQuery(GetProtectedQueryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetProtectedQueryRequestMarshaller.Instance; options.ResponseUnmarshaller = GetProtectedQueryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetProtectedQuery. /// /// Returns a GetProtectedQueryResult from CleanRooms. /// REST API Reference for GetProtectedQuery Operation public virtual GetProtectedQueryResponse EndGetProtectedQuery(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetSchema ///

/// Retrieves the schema for a relation within a collaboration. ///

/// Container for the necessary parameters to execute the GetSchema service method. /// /// The response from the GetSchema service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for GetSchema Operation public virtual GetSchemaResponse GetSchema(GetSchemaRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetSchemaRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSchemaResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetSchema operation on AmazonCleanRoomsClient. /// 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 EndGetSchema /// operation. /// REST API Reference for GetSchema Operation public virtual IAsyncResult BeginGetSchema(GetSchemaRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetSchemaRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSchemaResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetSchema. /// /// Returns a GetSchemaResult from CleanRooms. /// REST API Reference for GetSchema Operation public virtual GetSchemaResponse EndGetSchema(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetSchemaAnalysisRule ///

/// Retrieves a schema analysis rule. ///

/// Container for the necessary parameters to execute the GetSchemaAnalysisRule service method. /// /// The response from the GetSchemaAnalysisRule service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for GetSchemaAnalysisRule Operation public virtual GetSchemaAnalysisRuleResponse GetSchemaAnalysisRule(GetSchemaAnalysisRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetSchemaAnalysisRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSchemaAnalysisRuleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetSchemaAnalysisRule operation on AmazonCleanRoomsClient. /// 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 EndGetSchemaAnalysisRule /// operation. /// REST API Reference for GetSchemaAnalysisRule Operation public virtual IAsyncResult BeginGetSchemaAnalysisRule(GetSchemaAnalysisRuleRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetSchemaAnalysisRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSchemaAnalysisRuleResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetSchemaAnalysisRule. /// /// Returns a GetSchemaAnalysisRuleResult from CleanRooms. /// REST API Reference for GetSchemaAnalysisRule Operation public virtual GetSchemaAnalysisRuleResponse EndGetSchemaAnalysisRule(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListCollaborations ///

/// Lists collaborations the caller owns, is active in, or has been invited to. ///

/// Container for the necessary parameters to execute the ListCollaborations service method. /// /// The response from the ListCollaborations service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for ListCollaborations Operation public virtual ListCollaborationsResponse ListCollaborations(ListCollaborationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListCollaborationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCollaborationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListCollaborations operation on AmazonCleanRoomsClient. /// 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 EndListCollaborations /// operation. /// REST API Reference for ListCollaborations Operation public virtual IAsyncResult BeginListCollaborations(ListCollaborationsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListCollaborationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCollaborationsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListCollaborations. /// /// Returns a ListCollaborationsResult from CleanRooms. /// REST API Reference for ListCollaborations Operation public virtual ListCollaborationsResponse EndListCollaborations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListConfiguredTableAssociations ///

/// Lists configured table associations for a membership. ///

/// Container for the necessary parameters to execute the ListConfiguredTableAssociations service method. /// /// The response from the ListConfiguredTableAssociations service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for ListConfiguredTableAssociations Operation public virtual ListConfiguredTableAssociationsResponse ListConfiguredTableAssociations(ListConfiguredTableAssociationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListConfiguredTableAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListConfiguredTableAssociationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListConfiguredTableAssociations operation on AmazonCleanRoomsClient. /// 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 EndListConfiguredTableAssociations /// operation. /// REST API Reference for ListConfiguredTableAssociations Operation public virtual IAsyncResult BeginListConfiguredTableAssociations(ListConfiguredTableAssociationsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListConfiguredTableAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListConfiguredTableAssociationsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListConfiguredTableAssociations. /// /// Returns a ListConfiguredTableAssociationsResult from CleanRooms. /// REST API Reference for ListConfiguredTableAssociations Operation public virtual ListConfiguredTableAssociationsResponse EndListConfiguredTableAssociations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListConfiguredTables ///

/// Lists configured tables. ///

/// Container for the necessary parameters to execute the ListConfiguredTables service method. /// /// The response from the ListConfiguredTables service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for ListConfiguredTables Operation public virtual ListConfiguredTablesResponse ListConfiguredTables(ListConfiguredTablesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListConfiguredTablesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListConfiguredTablesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListConfiguredTables operation on AmazonCleanRoomsClient. /// 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 EndListConfiguredTables /// operation. /// REST API Reference for ListConfiguredTables Operation public virtual IAsyncResult BeginListConfiguredTables(ListConfiguredTablesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListConfiguredTablesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListConfiguredTablesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListConfiguredTables. /// /// Returns a ListConfiguredTablesResult from CleanRooms. /// REST API Reference for ListConfiguredTables Operation public virtual ListConfiguredTablesResponse EndListConfiguredTables(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListMembers ///

/// Lists all members within a collaboration. ///

/// Container for the necessary parameters to execute the ListMembers service method. /// /// The response from the ListMembers service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for ListMembers Operation public virtual ListMembersResponse ListMembers(ListMembersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListMembersRequestMarshaller.Instance; options.ResponseUnmarshaller = ListMembersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListMembers operation on AmazonCleanRoomsClient. /// 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 EndListMembers /// operation. /// REST API Reference for ListMembers Operation public virtual IAsyncResult BeginListMembers(ListMembersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListMembersRequestMarshaller.Instance; options.ResponseUnmarshaller = ListMembersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListMembers. /// /// Returns a ListMembersResult from CleanRooms. /// REST API Reference for ListMembers Operation public virtual ListMembersResponse EndListMembers(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListMemberships ///

/// Lists all memberships resources within the caller's account. ///

/// Container for the necessary parameters to execute the ListMemberships service method. /// /// The response from the ListMemberships service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for ListMemberships Operation public virtual ListMembershipsResponse ListMemberships(ListMembershipsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListMembershipsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListMembershipsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListMemberships operation on AmazonCleanRoomsClient. /// 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 EndListMemberships /// operation. /// REST API Reference for ListMemberships Operation public virtual IAsyncResult BeginListMemberships(ListMembershipsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListMembershipsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListMembershipsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListMemberships. /// /// Returns a ListMembershipsResult from CleanRooms. /// REST API Reference for ListMemberships Operation public virtual ListMembershipsResponse EndListMemberships(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListProtectedQueries ///

/// Lists protected queries, sorted by the most recent query. ///

/// Container for the necessary parameters to execute the ListProtectedQueries service method. /// /// The response from the ListProtectedQueries service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for ListProtectedQueries Operation public virtual ListProtectedQueriesResponse ListProtectedQueries(ListProtectedQueriesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListProtectedQueriesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListProtectedQueriesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListProtectedQueries operation on AmazonCleanRoomsClient. /// 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 EndListProtectedQueries /// operation. /// REST API Reference for ListProtectedQueries Operation public virtual IAsyncResult BeginListProtectedQueries(ListProtectedQueriesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListProtectedQueriesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListProtectedQueriesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListProtectedQueries. /// /// Returns a ListProtectedQueriesResult from CleanRooms. /// REST API Reference for ListProtectedQueries Operation public virtual ListProtectedQueriesResponse EndListProtectedQueries(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListSchemas ///

/// Lists the schemas for relations within a collaboration. ///

/// Container for the necessary parameters to execute the ListSchemas service method. /// /// The response from the ListSchemas service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for ListSchemas Operation public virtual ListSchemasResponse ListSchemas(ListSchemasRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListSchemasRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSchemasResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListSchemas operation on AmazonCleanRoomsClient. /// 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 EndListSchemas /// operation. /// REST API Reference for ListSchemas Operation public virtual IAsyncResult BeginListSchemas(ListSchemasRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListSchemasRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSchemasResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListSchemas. /// /// Returns a ListSchemasResult from CleanRooms. /// REST API Reference for ListSchemas Operation public virtual ListSchemasResponse EndListSchemas(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTagsForResource ///

/// Lists all of the tags that have been added to a resource. ///

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// The response from the ListTagsForResource service method, as returned by CleanRooms. /// /// Request references a resource which does not exist. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginListTagsForResource. /// /// Returns a ListTagsForResourceResult from CleanRooms. /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse EndListTagsForResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartProtectedQuery ///

/// Creates a protected query that is started by Clean Rooms . ///

/// Container for the necessary parameters to execute the StartProtectedQuery service method. /// /// The response from the StartProtectedQuery service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request denied because service quota has been exceeded. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for StartProtectedQuery Operation public virtual StartProtectedQueryResponse StartProtectedQuery(StartProtectedQueryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartProtectedQueryRequestMarshaller.Instance; options.ResponseUnmarshaller = StartProtectedQueryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the StartProtectedQuery operation on AmazonCleanRoomsClient. /// 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 EndStartProtectedQuery /// operation. /// REST API Reference for StartProtectedQuery Operation public virtual IAsyncResult BeginStartProtectedQuery(StartProtectedQueryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartProtectedQueryRequestMarshaller.Instance; options.ResponseUnmarshaller = StartProtectedQueryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginStartProtectedQuery. /// /// Returns a StartProtectedQueryResult from CleanRooms. /// REST API Reference for StartProtectedQuery Operation public virtual StartProtectedQueryResponse EndStartProtectedQuery(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region TagResource ///

/// Tags a resource. ///

/// Container for the necessary parameters to execute the TagResource service method. /// /// The response from the TagResource service method, as returned by CleanRooms. /// /// Request references a resource which does not exist. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for TagResource Operation public virtual TagResourceResponse TagResource(TagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginTagResource. /// /// Returns a TagResourceResult from CleanRooms. /// REST API Reference for TagResource Operation public virtual TagResourceResponse EndTagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UntagResource ///

/// Removes a tag or list of tags from a resource. ///

/// Container for the necessary parameters to execute the UntagResource service method. /// /// The response from the UntagResource service method, as returned by CleanRooms. /// /// Request references a resource which does not exist. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse UntagResource(UntagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginUntagResource. /// /// Returns a UntagResourceResult from CleanRooms. /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse EndUntagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateCollaboration ///

/// Updates collaboration metadata and can only be called by the collaboration owner. ///

/// Container for the necessary parameters to execute the UpdateCollaboration service method. /// /// The response from the UpdateCollaboration service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Unexpected error during processing of request. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for UpdateCollaboration Operation public virtual UpdateCollaborationResponse UpdateCollaboration(UpdateCollaborationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateCollaborationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateCollaborationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateCollaboration operation on AmazonCleanRoomsClient. /// 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 EndUpdateCollaboration /// operation. /// REST API Reference for UpdateCollaboration Operation public virtual IAsyncResult BeginUpdateCollaboration(UpdateCollaborationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateCollaborationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateCollaborationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateCollaboration. /// /// Returns a UpdateCollaborationResult from CleanRooms. /// REST API Reference for UpdateCollaboration Operation public virtual UpdateCollaborationResponse EndUpdateCollaboration(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateConfiguredTable ///

/// Updates a configured table. ///

/// Container for the necessary parameters to execute the UpdateConfiguredTable service method. /// /// The response from the UpdateConfiguredTable service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Updating or deleting a resource can cause an inconsistent state. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for UpdateConfiguredTable Operation public virtual UpdateConfiguredTableResponse UpdateConfiguredTable(UpdateConfiguredTableRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateConfiguredTableRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateConfiguredTableResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateConfiguredTable operation on AmazonCleanRoomsClient. /// 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 EndUpdateConfiguredTable /// operation. /// REST API Reference for UpdateConfiguredTable Operation public virtual IAsyncResult BeginUpdateConfiguredTable(UpdateConfiguredTableRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateConfiguredTableRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateConfiguredTableResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateConfiguredTable. /// /// Returns a UpdateConfiguredTableResult from CleanRooms. /// REST API Reference for UpdateConfiguredTable Operation public virtual UpdateConfiguredTableResponse EndUpdateConfiguredTable(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateConfiguredTableAnalysisRule ///

/// Updates a configured table analysis rule. ///

/// Container for the necessary parameters to execute the UpdateConfiguredTableAnalysisRule service method. /// /// The response from the UpdateConfiguredTableAnalysisRule service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Updating or deleting a resource can cause an inconsistent state. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for UpdateConfiguredTableAnalysisRule Operation public virtual UpdateConfiguredTableAnalysisRuleResponse UpdateConfiguredTableAnalysisRule(UpdateConfiguredTableAnalysisRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateConfiguredTableAnalysisRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateConfiguredTableAnalysisRuleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateConfiguredTableAnalysisRule operation on AmazonCleanRoomsClient. /// 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 EndUpdateConfiguredTableAnalysisRule /// operation. /// REST API Reference for UpdateConfiguredTableAnalysisRule Operation public virtual IAsyncResult BeginUpdateConfiguredTableAnalysisRule(UpdateConfiguredTableAnalysisRuleRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateConfiguredTableAnalysisRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateConfiguredTableAnalysisRuleResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateConfiguredTableAnalysisRule. /// /// Returns a UpdateConfiguredTableAnalysisRuleResult from CleanRooms. /// REST API Reference for UpdateConfiguredTableAnalysisRule Operation public virtual UpdateConfiguredTableAnalysisRuleResponse EndUpdateConfiguredTableAnalysisRule(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateConfiguredTableAssociation ///

/// Updates a configured table association. ///

/// Container for the necessary parameters to execute the UpdateConfiguredTableAssociation service method. /// /// The response from the UpdateConfiguredTableAssociation service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Updating or deleting a resource can cause an inconsistent state. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for UpdateConfiguredTableAssociation Operation public virtual UpdateConfiguredTableAssociationResponse UpdateConfiguredTableAssociation(UpdateConfiguredTableAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateConfiguredTableAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateConfiguredTableAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateConfiguredTableAssociation operation on AmazonCleanRoomsClient. /// 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 EndUpdateConfiguredTableAssociation /// operation. /// REST API Reference for UpdateConfiguredTableAssociation Operation public virtual IAsyncResult BeginUpdateConfiguredTableAssociation(UpdateConfiguredTableAssociationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateConfiguredTableAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateConfiguredTableAssociationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateConfiguredTableAssociation. /// /// Returns a UpdateConfiguredTableAssociationResult from CleanRooms. /// REST API Reference for UpdateConfiguredTableAssociation Operation public virtual UpdateConfiguredTableAssociationResponse EndUpdateConfiguredTableAssociation(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateMembership ///

/// Updates a membership. ///

/// Container for the necessary parameters to execute the UpdateMembership service method. /// /// The response from the UpdateMembership service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Updating or deleting a resource can cause an inconsistent state. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for UpdateMembership Operation public virtual UpdateMembershipResponse UpdateMembership(UpdateMembershipRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateMembershipRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateMembershipResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateMembership operation on AmazonCleanRoomsClient. /// 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 EndUpdateMembership /// operation. /// REST API Reference for UpdateMembership Operation public virtual IAsyncResult BeginUpdateMembership(UpdateMembershipRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateMembershipRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateMembershipResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateMembership. /// /// Returns a UpdateMembershipResult from CleanRooms. /// REST API Reference for UpdateMembership Operation public virtual UpdateMembershipResponse EndUpdateMembership(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateProtectedQuery ///

/// Updates the processing of a currently running query. ///

/// Container for the necessary parameters to execute the UpdateProtectedQuery service method. /// /// The response from the UpdateProtectedQuery service method, as returned by CleanRooms. /// /// Caller does not have sufficient access to perform this action. /// /// /// Updating or deleting a resource can cause an inconsistent state. /// /// /// Unexpected error during processing of request. /// /// /// Request references a resource which does not exist. /// /// /// Request was denied due to request throttling. /// /// /// The input fails to satisfy the specified constraints. /// /// REST API Reference for UpdateProtectedQuery Operation public virtual UpdateProtectedQueryResponse UpdateProtectedQuery(UpdateProtectedQueryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateProtectedQueryRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateProtectedQueryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateProtectedQuery operation on AmazonCleanRoomsClient. /// 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 EndUpdateProtectedQuery /// operation. /// REST API Reference for UpdateProtectedQuery Operation public virtual IAsyncResult BeginUpdateProtectedQuery(UpdateProtectedQueryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateProtectedQueryRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateProtectedQueryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateProtectedQuery. /// /// Returns a UpdateProtectedQueryResult from CleanRooms. /// REST API Reference for UpdateProtectedQuery Operation public virtual UpdateProtectedQueryResponse EndUpdateProtectedQuery(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }