CleanRoomsClient.h

 
#pragma once
#include <aws/cleanrooms/CleanRoomsPaginationBase.h>
#include <aws/cleanrooms/CleanRoomsServiceClientModel.h>
#include <aws/cleanrooms/CleanRoomsWaiter.h>
#include <aws/cleanrooms/CleanRooms_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace CleanRooms {
class AWS_CLEANROOMS_API CleanRoomsClient : public Aws::Client::AWSJsonClient,
                                            public Aws::Client::ClientWithAsyncTemplateMethods<CleanRoomsClient>,
                                            public CleanRoomsPaginationBase<CleanRoomsClient>,
                                            public CleanRoomsWaiter<CleanRoomsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef CleanRoomsClientConfiguration ClientConfigurationType;
  typedef CleanRoomsEndpointProvider EndpointProviderType;
 
  CleanRoomsClient(
      const Aws::CleanRooms::CleanRoomsClientConfiguration& clientConfiguration = Aws::CleanRooms::CleanRoomsClientConfiguration(),
      std::shared_ptr<CleanRoomsEndpointProviderBase> endpointProvider = nullptr);
 
  CleanRoomsClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<CleanRoomsEndpointProviderBase> endpointProvider = nullptr,
      const Aws::CleanRooms::CleanRoomsClientConfiguration& clientConfiguration = Aws::CleanRooms::CleanRoomsClientConfiguration());
 
  CleanRoomsClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<CleanRoomsEndpointProviderBase> endpointProvider = nullptr,
      const Aws::CleanRooms::CleanRoomsClientConfiguration& clientConfiguration = Aws::CleanRooms::CleanRoomsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  CleanRoomsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CleanRoomsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CleanRoomsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~CleanRoomsClient();
 
  virtual Model::BatchGetCollaborationAnalysisTemplateOutcome BatchGetCollaborationAnalysisTemplate(
      const Model::BatchGetCollaborationAnalysisTemplateRequest& request) const;
 
  template <typename BatchGetCollaborationAnalysisTemplateRequestT = Model::BatchGetCollaborationAnalysisTemplateRequest>
  Model::BatchGetCollaborationAnalysisTemplateOutcomeCallable BatchGetCollaborationAnalysisTemplateCallable(
      const BatchGetCollaborationAnalysisTemplateRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::BatchGetCollaborationAnalysisTemplate, request);
  }
 
  template <typename BatchGetCollaborationAnalysisTemplateRequestT = Model::BatchGetCollaborationAnalysisTemplateRequest>
  void BatchGetCollaborationAnalysisTemplateAsync(const BatchGetCollaborationAnalysisTemplateRequestT& request,
                                                  const BatchGetCollaborationAnalysisTemplateResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::BatchGetCollaborationAnalysisTemplate, request, handler, context);
  }
 
  virtual Model::BatchGetSchemaOutcome BatchGetSchema(const Model::BatchGetSchemaRequest& request) const;
 
  template <typename BatchGetSchemaRequestT = Model::BatchGetSchemaRequest>
  Model::BatchGetSchemaOutcomeCallable BatchGetSchemaCallable(const BatchGetSchemaRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::BatchGetSchema, request);
  }
 
  template <typename BatchGetSchemaRequestT = Model::BatchGetSchemaRequest>
  void BatchGetSchemaAsync(const BatchGetSchemaRequestT& request, const BatchGetSchemaResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::BatchGetSchema, request, handler, context);
  }
 
  virtual Model::BatchGetSchemaAnalysisRuleOutcome BatchGetSchemaAnalysisRule(
      const Model::BatchGetSchemaAnalysisRuleRequest& request) const;
 
  template <typename BatchGetSchemaAnalysisRuleRequestT = Model::BatchGetSchemaAnalysisRuleRequest>
  Model::BatchGetSchemaAnalysisRuleOutcomeCallable BatchGetSchemaAnalysisRuleCallable(
      const BatchGetSchemaAnalysisRuleRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::BatchGetSchemaAnalysisRule, request);
  }
 
  template <typename BatchGetSchemaAnalysisRuleRequestT = Model::BatchGetSchemaAnalysisRuleRequest>
  void BatchGetSchemaAnalysisRuleAsync(const BatchGetSchemaAnalysisRuleRequestT& request,
                                       const BatchGetSchemaAnalysisRuleResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::BatchGetSchemaAnalysisRule, request, handler, context);
  }
 
  virtual Model::CreateAnalysisTemplateOutcome CreateAnalysisTemplate(const Model::CreateAnalysisTemplateRequest& request) const;
 
  template <typename CreateAnalysisTemplateRequestT = Model::CreateAnalysisTemplateRequest>
  Model::CreateAnalysisTemplateOutcomeCallable CreateAnalysisTemplateCallable(const CreateAnalysisTemplateRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::CreateAnalysisTemplate, request);
  }
 
  template <typename CreateAnalysisTemplateRequestT = Model::CreateAnalysisTemplateRequest>
  void CreateAnalysisTemplateAsync(const CreateAnalysisTemplateRequestT& request,
                                   const CreateAnalysisTemplateResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::CreateAnalysisTemplate, request, handler, context);
  }
 
  virtual Model::CreateCollaborationOutcome CreateCollaboration(const Model::CreateCollaborationRequest& request) const;
 
  template <typename CreateCollaborationRequestT = Model::CreateCollaborationRequest>
  Model::CreateCollaborationOutcomeCallable CreateCollaborationCallable(const CreateCollaborationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::CreateCollaboration, request);
  }
 
  template <typename CreateCollaborationRequestT = Model::CreateCollaborationRequest>
  void CreateCollaborationAsync(const CreateCollaborationRequestT& request, const CreateCollaborationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::CreateCollaboration, request, handler, context);
  }
 
  virtual Model::CreateCollaborationChangeRequestOutcome CreateCollaborationChangeRequest(
      const Model::CreateCollaborationChangeRequestRequest& request) const;
 
  template <typename CreateCollaborationChangeRequestRequestT = Model::CreateCollaborationChangeRequestRequest>
  Model::CreateCollaborationChangeRequestOutcomeCallable CreateCollaborationChangeRequestCallable(
      const CreateCollaborationChangeRequestRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::CreateCollaborationChangeRequest, request);
  }
 
  template <typename CreateCollaborationChangeRequestRequestT = Model::CreateCollaborationChangeRequestRequest>
  void CreateCollaborationChangeRequestAsync(const CreateCollaborationChangeRequestRequestT& request,
                                             const CreateCollaborationChangeRequestResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::CreateCollaborationChangeRequest, request, handler, context);
  }
 
  virtual Model::CreateConfiguredAudienceModelAssociationOutcome CreateConfiguredAudienceModelAssociation(
      const Model::CreateConfiguredAudienceModelAssociationRequest& request) const;
 
  template <typename CreateConfiguredAudienceModelAssociationRequestT = Model::CreateConfiguredAudienceModelAssociationRequest>
  Model::CreateConfiguredAudienceModelAssociationOutcomeCallable CreateConfiguredAudienceModelAssociationCallable(
      const CreateConfiguredAudienceModelAssociationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::CreateConfiguredAudienceModelAssociation, request);
  }
 
  template <typename CreateConfiguredAudienceModelAssociationRequestT = Model::CreateConfiguredAudienceModelAssociationRequest>
  void CreateConfiguredAudienceModelAssociationAsync(
      const CreateConfiguredAudienceModelAssociationRequestT& request,
      const CreateConfiguredAudienceModelAssociationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::CreateConfiguredAudienceModelAssociation, request, handler, context);
  }
 
  virtual Model::CreateConfiguredTableOutcome CreateConfiguredTable(const Model::CreateConfiguredTableRequest& request) const;
 
  template <typename CreateConfiguredTableRequestT = Model::CreateConfiguredTableRequest>
  Model::CreateConfiguredTableOutcomeCallable CreateConfiguredTableCallable(const CreateConfiguredTableRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::CreateConfiguredTable, request);
  }
 
  template <typename CreateConfiguredTableRequestT = Model::CreateConfiguredTableRequest>
  void CreateConfiguredTableAsync(const CreateConfiguredTableRequestT& request, const CreateConfiguredTableResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::CreateConfiguredTable, request, handler, context);
  }
 
  virtual Model::CreateConfiguredTableAnalysisRuleOutcome CreateConfiguredTableAnalysisRule(
      const Model::CreateConfiguredTableAnalysisRuleRequest& request) const;
 
  template <typename CreateConfiguredTableAnalysisRuleRequestT = Model::CreateConfiguredTableAnalysisRuleRequest>
  Model::CreateConfiguredTableAnalysisRuleOutcomeCallable CreateConfiguredTableAnalysisRuleCallable(
      const CreateConfiguredTableAnalysisRuleRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::CreateConfiguredTableAnalysisRule, request);
  }
 
  template <typename CreateConfiguredTableAnalysisRuleRequestT = Model::CreateConfiguredTableAnalysisRuleRequest>
  void CreateConfiguredTableAnalysisRuleAsync(const CreateConfiguredTableAnalysisRuleRequestT& request,
                                              const CreateConfiguredTableAnalysisRuleResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::CreateConfiguredTableAnalysisRule, request, handler, context);
  }
 
  virtual Model::CreateConfiguredTableAssociationOutcome CreateConfiguredTableAssociation(
      const Model::CreateConfiguredTableAssociationRequest& request) const;
 
  template <typename CreateConfiguredTableAssociationRequestT = Model::CreateConfiguredTableAssociationRequest>
  Model::CreateConfiguredTableAssociationOutcomeCallable CreateConfiguredTableAssociationCallable(
      const CreateConfiguredTableAssociationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::CreateConfiguredTableAssociation, request);
  }
 
  template <typename CreateConfiguredTableAssociationRequestT = Model::CreateConfiguredTableAssociationRequest>
  void CreateConfiguredTableAssociationAsync(const CreateConfiguredTableAssociationRequestT& request,
                                             const CreateConfiguredTableAssociationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::CreateConfiguredTableAssociation, request, handler, context);
  }
 
  virtual Model::CreateConfiguredTableAssociationAnalysisRuleOutcome CreateConfiguredTableAssociationAnalysisRule(
      const Model::CreateConfiguredTableAssociationAnalysisRuleRequest& request) const;
 
  template <typename CreateConfiguredTableAssociationAnalysisRuleRequestT = Model::CreateConfiguredTableAssociationAnalysisRuleRequest>
  Model::CreateConfiguredTableAssociationAnalysisRuleOutcomeCallable CreateConfiguredTableAssociationAnalysisRuleCallable(
      const CreateConfiguredTableAssociationAnalysisRuleRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::CreateConfiguredTableAssociationAnalysisRule, request);
  }
 
  template <typename CreateConfiguredTableAssociationAnalysisRuleRequestT = Model::CreateConfiguredTableAssociationAnalysisRuleRequest>
  void CreateConfiguredTableAssociationAnalysisRuleAsync(
      const CreateConfiguredTableAssociationAnalysisRuleRequestT& request,
      const CreateConfiguredTableAssociationAnalysisRuleResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::CreateConfiguredTableAssociationAnalysisRule, request, handler, context);
  }
 
  virtual Model::CreateIdMappingTableOutcome CreateIdMappingTable(const Model::CreateIdMappingTableRequest& request) const;
 
  template <typename CreateIdMappingTableRequestT = Model::CreateIdMappingTableRequest>
  Model::CreateIdMappingTableOutcomeCallable CreateIdMappingTableCallable(const CreateIdMappingTableRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::CreateIdMappingTable, request);
  }
 
  template <typename CreateIdMappingTableRequestT = Model::CreateIdMappingTableRequest>
  void CreateIdMappingTableAsync(const CreateIdMappingTableRequestT& request, const CreateIdMappingTableResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::CreateIdMappingTable, request, handler, context);
  }
 
  virtual Model::CreateIdNamespaceAssociationOutcome CreateIdNamespaceAssociation(
      const Model::CreateIdNamespaceAssociationRequest& request) const;
 
  template <typename CreateIdNamespaceAssociationRequestT = Model::CreateIdNamespaceAssociationRequest>
  Model::CreateIdNamespaceAssociationOutcomeCallable CreateIdNamespaceAssociationCallable(
      const CreateIdNamespaceAssociationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::CreateIdNamespaceAssociation, request);
  }
 
  template <typename CreateIdNamespaceAssociationRequestT = Model::CreateIdNamespaceAssociationRequest>
  void CreateIdNamespaceAssociationAsync(const CreateIdNamespaceAssociationRequestT& request,
                                         const CreateIdNamespaceAssociationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::CreateIdNamespaceAssociation, request, handler, context);
  }
 
  virtual Model::CreateIntermediateTableOutcome CreateIntermediateTable(const Model::CreateIntermediateTableRequest& request) const;
 
  template <typename CreateIntermediateTableRequestT = Model::CreateIntermediateTableRequest>
  Model::CreateIntermediateTableOutcomeCallable CreateIntermediateTableCallable(const CreateIntermediateTableRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::CreateIntermediateTable, request);
  }
 
  template <typename CreateIntermediateTableRequestT = Model::CreateIntermediateTableRequest>
  void CreateIntermediateTableAsync(const CreateIntermediateTableRequestT& request,
                                    const CreateIntermediateTableResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::CreateIntermediateTable, request, handler, context);
  }
 
  virtual Model::CreateIntermediateTableAnalysisRuleOutcome CreateIntermediateTableAnalysisRule(
      const Model::CreateIntermediateTableAnalysisRuleRequest& request) const;
 
  template <typename CreateIntermediateTableAnalysisRuleRequestT = Model::CreateIntermediateTableAnalysisRuleRequest>
  Model::CreateIntermediateTableAnalysisRuleOutcomeCallable CreateIntermediateTableAnalysisRuleCallable(
      const CreateIntermediateTableAnalysisRuleRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::CreateIntermediateTableAnalysisRule, request);
  }
 
  template <typename CreateIntermediateTableAnalysisRuleRequestT = Model::CreateIntermediateTableAnalysisRuleRequest>
  void CreateIntermediateTableAnalysisRuleAsync(const CreateIntermediateTableAnalysisRuleRequestT& request,
                                                const CreateIntermediateTableAnalysisRuleResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::CreateIntermediateTableAnalysisRule, request, handler, context);
  }
 
  virtual Model::CreateMembershipOutcome CreateMembership(const Model::CreateMembershipRequest& request) const;
 
  template <typename CreateMembershipRequestT = Model::CreateMembershipRequest>
  Model::CreateMembershipOutcomeCallable CreateMembershipCallable(const CreateMembershipRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::CreateMembership, request);
  }
 
  template <typename CreateMembershipRequestT = Model::CreateMembershipRequest>
  void CreateMembershipAsync(const CreateMembershipRequestT& request, const CreateMembershipResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::CreateMembership, request, handler, context);
  }
 
  virtual Model::CreatePrivacyBudgetTemplateOutcome CreatePrivacyBudgetTemplate(
      const Model::CreatePrivacyBudgetTemplateRequest& request) const;
 
  template <typename CreatePrivacyBudgetTemplateRequestT = Model::CreatePrivacyBudgetTemplateRequest>
  Model::CreatePrivacyBudgetTemplateOutcomeCallable CreatePrivacyBudgetTemplateCallable(
      const CreatePrivacyBudgetTemplateRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::CreatePrivacyBudgetTemplate, request);
  }
 
  template <typename CreatePrivacyBudgetTemplateRequestT = Model::CreatePrivacyBudgetTemplateRequest>
  void CreatePrivacyBudgetTemplateAsync(const CreatePrivacyBudgetTemplateRequestT& request,
                                        const CreatePrivacyBudgetTemplateResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::CreatePrivacyBudgetTemplate, request, handler, context);
  }
 
  virtual Model::DeleteAnalysisTemplateOutcome DeleteAnalysisTemplate(const Model::DeleteAnalysisTemplateRequest& request) const;
 
  template <typename DeleteAnalysisTemplateRequestT = Model::DeleteAnalysisTemplateRequest>
  Model::DeleteAnalysisTemplateOutcomeCallable DeleteAnalysisTemplateCallable(const DeleteAnalysisTemplateRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::DeleteAnalysisTemplate, request);
  }
 
  template <typename DeleteAnalysisTemplateRequestT = Model::DeleteAnalysisTemplateRequest>
  void DeleteAnalysisTemplateAsync(const DeleteAnalysisTemplateRequestT& request,
                                   const DeleteAnalysisTemplateResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::DeleteAnalysisTemplate, request, handler, context);
  }
 
  virtual Model::DeleteCollaborationOutcome DeleteCollaboration(const Model::DeleteCollaborationRequest& request) const;
 
  template <typename DeleteCollaborationRequestT = Model::DeleteCollaborationRequest>
  Model::DeleteCollaborationOutcomeCallable DeleteCollaborationCallable(const DeleteCollaborationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::DeleteCollaboration, request);
  }
 
  template <typename DeleteCollaborationRequestT = Model::DeleteCollaborationRequest>
  void DeleteCollaborationAsync(const DeleteCollaborationRequestT& request, const DeleteCollaborationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::DeleteCollaboration, request, handler, context);
  }
 
  virtual Model::DeleteConfiguredAudienceModelAssociationOutcome DeleteConfiguredAudienceModelAssociation(
      const Model::DeleteConfiguredAudienceModelAssociationRequest& request) const;
 
  template <typename DeleteConfiguredAudienceModelAssociationRequestT = Model::DeleteConfiguredAudienceModelAssociationRequest>
  Model::DeleteConfiguredAudienceModelAssociationOutcomeCallable DeleteConfiguredAudienceModelAssociationCallable(
      const DeleteConfiguredAudienceModelAssociationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::DeleteConfiguredAudienceModelAssociation, request);
  }
 
  template <typename DeleteConfiguredAudienceModelAssociationRequestT = Model::DeleteConfiguredAudienceModelAssociationRequest>
  void DeleteConfiguredAudienceModelAssociationAsync(
      const DeleteConfiguredAudienceModelAssociationRequestT& request,
      const DeleteConfiguredAudienceModelAssociationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::DeleteConfiguredAudienceModelAssociation, request, handler, context);
  }
 
  virtual Model::DeleteConfiguredTableOutcome DeleteConfiguredTable(const Model::DeleteConfiguredTableRequest& request) const;
 
  template <typename DeleteConfiguredTableRequestT = Model::DeleteConfiguredTableRequest>
  Model::DeleteConfiguredTableOutcomeCallable DeleteConfiguredTableCallable(const DeleteConfiguredTableRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::DeleteConfiguredTable, request);
  }
 
  template <typename DeleteConfiguredTableRequestT = Model::DeleteConfiguredTableRequest>
  void DeleteConfiguredTableAsync(const DeleteConfiguredTableRequestT& request, const DeleteConfiguredTableResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::DeleteConfiguredTable, request, handler, context);
  }
 
  virtual Model::DeleteConfiguredTableAnalysisRuleOutcome DeleteConfiguredTableAnalysisRule(
      const Model::DeleteConfiguredTableAnalysisRuleRequest& request) const;
 
  template <typename DeleteConfiguredTableAnalysisRuleRequestT = Model::DeleteConfiguredTableAnalysisRuleRequest>
  Model::DeleteConfiguredTableAnalysisRuleOutcomeCallable DeleteConfiguredTableAnalysisRuleCallable(
      const DeleteConfiguredTableAnalysisRuleRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::DeleteConfiguredTableAnalysisRule, request);
  }
 
  template <typename DeleteConfiguredTableAnalysisRuleRequestT = Model::DeleteConfiguredTableAnalysisRuleRequest>
  void DeleteConfiguredTableAnalysisRuleAsync(const DeleteConfiguredTableAnalysisRuleRequestT& request,
                                              const DeleteConfiguredTableAnalysisRuleResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::DeleteConfiguredTableAnalysisRule, request, handler, context);
  }
 
  virtual Model::DeleteConfiguredTableAssociationOutcome DeleteConfiguredTableAssociation(
      const Model::DeleteConfiguredTableAssociationRequest& request) const;
 
  template <typename DeleteConfiguredTableAssociationRequestT = Model::DeleteConfiguredTableAssociationRequest>
  Model::DeleteConfiguredTableAssociationOutcomeCallable DeleteConfiguredTableAssociationCallable(
      const DeleteConfiguredTableAssociationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::DeleteConfiguredTableAssociation, request);
  }
 
  template <typename DeleteConfiguredTableAssociationRequestT = Model::DeleteConfiguredTableAssociationRequest>
  void DeleteConfiguredTableAssociationAsync(const DeleteConfiguredTableAssociationRequestT& request,
                                             const DeleteConfiguredTableAssociationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::DeleteConfiguredTableAssociation, request, handler, context);
  }
 
  virtual Model::DeleteConfiguredTableAssociationAnalysisRuleOutcome DeleteConfiguredTableAssociationAnalysisRule(
      const Model::DeleteConfiguredTableAssociationAnalysisRuleRequest& request) const;
 
  template <typename DeleteConfiguredTableAssociationAnalysisRuleRequestT = Model::DeleteConfiguredTableAssociationAnalysisRuleRequest>
  Model::DeleteConfiguredTableAssociationAnalysisRuleOutcomeCallable DeleteConfiguredTableAssociationAnalysisRuleCallable(
      const DeleteConfiguredTableAssociationAnalysisRuleRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::DeleteConfiguredTableAssociationAnalysisRule, request);
  }
 
  template <typename DeleteConfiguredTableAssociationAnalysisRuleRequestT = Model::DeleteConfiguredTableAssociationAnalysisRuleRequest>
  void DeleteConfiguredTableAssociationAnalysisRuleAsync(
      const DeleteConfiguredTableAssociationAnalysisRuleRequestT& request,
      const DeleteConfiguredTableAssociationAnalysisRuleResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::DeleteConfiguredTableAssociationAnalysisRule, request, handler, context);
  }
 
  virtual Model::DeleteIdMappingTableOutcome DeleteIdMappingTable(const Model::DeleteIdMappingTableRequest& request) const;
 
  template <typename DeleteIdMappingTableRequestT = Model::DeleteIdMappingTableRequest>
  Model::DeleteIdMappingTableOutcomeCallable DeleteIdMappingTableCallable(const DeleteIdMappingTableRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::DeleteIdMappingTable, request);
  }
 
  template <typename DeleteIdMappingTableRequestT = Model::DeleteIdMappingTableRequest>
  void DeleteIdMappingTableAsync(const DeleteIdMappingTableRequestT& request, const DeleteIdMappingTableResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::DeleteIdMappingTable, request, handler, context);
  }
 
  virtual Model::DeleteIdNamespaceAssociationOutcome DeleteIdNamespaceAssociation(
      const Model::DeleteIdNamespaceAssociationRequest& request) const;
 
  template <typename DeleteIdNamespaceAssociationRequestT = Model::DeleteIdNamespaceAssociationRequest>
  Model::DeleteIdNamespaceAssociationOutcomeCallable DeleteIdNamespaceAssociationCallable(
      const DeleteIdNamespaceAssociationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::DeleteIdNamespaceAssociation, request);
  }
 
  template <typename DeleteIdNamespaceAssociationRequestT = Model::DeleteIdNamespaceAssociationRequest>
  void DeleteIdNamespaceAssociationAsync(const DeleteIdNamespaceAssociationRequestT& request,
                                         const DeleteIdNamespaceAssociationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::DeleteIdNamespaceAssociation, request, handler, context);
  }
 
  virtual Model::DeleteIntermediateTableOutcome DeleteIntermediateTable(const Model::DeleteIntermediateTableRequest& request) const;
 
  template <typename DeleteIntermediateTableRequestT = Model::DeleteIntermediateTableRequest>
  Model::DeleteIntermediateTableOutcomeCallable DeleteIntermediateTableCallable(const DeleteIntermediateTableRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::DeleteIntermediateTable, request);
  }
 
  template <typename DeleteIntermediateTableRequestT = Model::DeleteIntermediateTableRequest>
  void DeleteIntermediateTableAsync(const DeleteIntermediateTableRequestT& request,
                                    const DeleteIntermediateTableResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::DeleteIntermediateTable, request, handler, context);
  }
 
  virtual Model::DeleteIntermediateTableAnalysisRuleOutcome DeleteIntermediateTableAnalysisRule(
      const Model::DeleteIntermediateTableAnalysisRuleRequest& request) const;
 
  template <typename DeleteIntermediateTableAnalysisRuleRequestT = Model::DeleteIntermediateTableAnalysisRuleRequest>
  Model::DeleteIntermediateTableAnalysisRuleOutcomeCallable DeleteIntermediateTableAnalysisRuleCallable(
      const DeleteIntermediateTableAnalysisRuleRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::DeleteIntermediateTableAnalysisRule, request);
  }
 
  template <typename DeleteIntermediateTableAnalysisRuleRequestT = Model::DeleteIntermediateTableAnalysisRuleRequest>
  void DeleteIntermediateTableAnalysisRuleAsync(const DeleteIntermediateTableAnalysisRuleRequestT& request,
                                                const DeleteIntermediateTableAnalysisRuleResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::DeleteIntermediateTableAnalysisRule, request, handler, context);
  }
 
  virtual Model::DeleteMemberOutcome DeleteMember(const Model::DeleteMemberRequest& request) const;
 
  template <typename DeleteMemberRequestT = Model::DeleteMemberRequest>
  Model::DeleteMemberOutcomeCallable DeleteMemberCallable(const DeleteMemberRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::DeleteMember, request);
  }
 
  template <typename DeleteMemberRequestT = Model::DeleteMemberRequest>
  void DeleteMemberAsync(const DeleteMemberRequestT& request, const DeleteMemberResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::DeleteMember, request, handler, context);
  }
 
  virtual Model::DeleteMembershipOutcome DeleteMembership(const Model::DeleteMembershipRequest& request) const;
 
  template <typename DeleteMembershipRequestT = Model::DeleteMembershipRequest>
  Model::DeleteMembershipOutcomeCallable DeleteMembershipCallable(const DeleteMembershipRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::DeleteMembership, request);
  }
 
  template <typename DeleteMembershipRequestT = Model::DeleteMembershipRequest>
  void DeleteMembershipAsync(const DeleteMembershipRequestT& request, const DeleteMembershipResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::DeleteMembership, request, handler, context);
  }
 
  virtual Model::DeletePrivacyBudgetTemplateOutcome DeletePrivacyBudgetTemplate(
      const Model::DeletePrivacyBudgetTemplateRequest& request) const;
 
  template <typename DeletePrivacyBudgetTemplateRequestT = Model::DeletePrivacyBudgetTemplateRequest>
  Model::DeletePrivacyBudgetTemplateOutcomeCallable DeletePrivacyBudgetTemplateCallable(
      const DeletePrivacyBudgetTemplateRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::DeletePrivacyBudgetTemplate, request);
  }
 
  template <typename DeletePrivacyBudgetTemplateRequestT = Model::DeletePrivacyBudgetTemplateRequest>
  void DeletePrivacyBudgetTemplateAsync(const DeletePrivacyBudgetTemplateRequestT& request,
                                        const DeletePrivacyBudgetTemplateResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::DeletePrivacyBudgetTemplate, request, handler, context);
  }
 
  virtual Model::DisallowIntermediateTableOutcome DisallowIntermediateTable(const Model::DisallowIntermediateTableRequest& request) const;
 
  template <typename DisallowIntermediateTableRequestT = Model::DisallowIntermediateTableRequest>
  Model::DisallowIntermediateTableOutcomeCallable DisallowIntermediateTableCallable(
      const DisallowIntermediateTableRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::DisallowIntermediateTable, request);
  }
 
  template <typename DisallowIntermediateTableRequestT = Model::DisallowIntermediateTableRequest>
  void DisallowIntermediateTableAsync(const DisallowIntermediateTableRequestT& request,
                                      const DisallowIntermediateTableResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::DisallowIntermediateTable, request, handler, context);
  }
 
  virtual Model::GetAnalysisLogExportOutcome GetAnalysisLogExport(const Model::GetAnalysisLogExportRequest& request) const;
 
  template <typename GetAnalysisLogExportRequestT = Model::GetAnalysisLogExportRequest>
  Model::GetAnalysisLogExportOutcomeCallable GetAnalysisLogExportCallable(const GetAnalysisLogExportRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetAnalysisLogExport, request);
  }
 
  template <typename GetAnalysisLogExportRequestT = Model::GetAnalysisLogExportRequest>
  void GetAnalysisLogExportAsync(const GetAnalysisLogExportRequestT& request, const GetAnalysisLogExportResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetAnalysisLogExport, request, handler, context);
  }
 
  virtual Model::GetAnalysisTemplateOutcome GetAnalysisTemplate(const Model::GetAnalysisTemplateRequest& request) const;
 
  template <typename GetAnalysisTemplateRequestT = Model::GetAnalysisTemplateRequest>
  Model::GetAnalysisTemplateOutcomeCallable GetAnalysisTemplateCallable(const GetAnalysisTemplateRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetAnalysisTemplate, request);
  }
 
  template <typename GetAnalysisTemplateRequestT = Model::GetAnalysisTemplateRequest>
  void GetAnalysisTemplateAsync(const GetAnalysisTemplateRequestT& request, const GetAnalysisTemplateResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetAnalysisTemplate, request, handler, context);
  }
 
  virtual Model::GetCollaborationOutcome GetCollaboration(const Model::GetCollaborationRequest& request) const;
 
  template <typename GetCollaborationRequestT = Model::GetCollaborationRequest>
  Model::GetCollaborationOutcomeCallable GetCollaborationCallable(const GetCollaborationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetCollaboration, request);
  }
 
  template <typename GetCollaborationRequestT = Model::GetCollaborationRequest>
  void GetCollaborationAsync(const GetCollaborationRequestT& request, const GetCollaborationResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetCollaboration, request, handler, context);
  }
 
  virtual Model::GetCollaborationAnalysisTemplateOutcome GetCollaborationAnalysisTemplate(
      const Model::GetCollaborationAnalysisTemplateRequest& request) const;
 
  template <typename GetCollaborationAnalysisTemplateRequestT = Model::GetCollaborationAnalysisTemplateRequest>
  Model::GetCollaborationAnalysisTemplateOutcomeCallable GetCollaborationAnalysisTemplateCallable(
      const GetCollaborationAnalysisTemplateRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetCollaborationAnalysisTemplate, request);
  }
 
  template <typename GetCollaborationAnalysisTemplateRequestT = Model::GetCollaborationAnalysisTemplateRequest>
  void GetCollaborationAnalysisTemplateAsync(const GetCollaborationAnalysisTemplateRequestT& request,
                                             const GetCollaborationAnalysisTemplateResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetCollaborationAnalysisTemplate, request, handler, context);
  }
 
  virtual Model::GetCollaborationChangeRequestOutcome GetCollaborationChangeRequest(
      const Model::GetCollaborationChangeRequestRequest& request) const;
 
  template <typename GetCollaborationChangeRequestRequestT = Model::GetCollaborationChangeRequestRequest>
  Model::GetCollaborationChangeRequestOutcomeCallable GetCollaborationChangeRequestCallable(
      const GetCollaborationChangeRequestRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetCollaborationChangeRequest, request);
  }
 
  template <typename GetCollaborationChangeRequestRequestT = Model::GetCollaborationChangeRequestRequest>
  void GetCollaborationChangeRequestAsync(const GetCollaborationChangeRequestRequestT& request,
                                          const GetCollaborationChangeRequestResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetCollaborationChangeRequest, request, handler, context);
  }
 
  virtual Model::GetCollaborationConfiguredAudienceModelAssociationOutcome GetCollaborationConfiguredAudienceModelAssociation(
      const Model::GetCollaborationConfiguredAudienceModelAssociationRequest& request) const;
 
  template <typename GetCollaborationConfiguredAudienceModelAssociationRequestT =
                Model::GetCollaborationConfiguredAudienceModelAssociationRequest>
  Model::GetCollaborationConfiguredAudienceModelAssociationOutcomeCallable GetCollaborationConfiguredAudienceModelAssociationCallable(
      const GetCollaborationConfiguredAudienceModelAssociationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetCollaborationConfiguredAudienceModelAssociation, request);
  }
 
  template <typename GetCollaborationConfiguredAudienceModelAssociationRequestT =
                Model::GetCollaborationConfiguredAudienceModelAssociationRequest>
  void GetCollaborationConfiguredAudienceModelAssociationAsync(
      const GetCollaborationConfiguredAudienceModelAssociationRequestT& request,
      const GetCollaborationConfiguredAudienceModelAssociationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetCollaborationConfiguredAudienceModelAssociation, request, handler, context);
  }
 
  virtual Model::GetCollaborationIdNamespaceAssociationOutcome GetCollaborationIdNamespaceAssociation(
      const Model::GetCollaborationIdNamespaceAssociationRequest& request) const;
 
  template <typename GetCollaborationIdNamespaceAssociationRequestT = Model::GetCollaborationIdNamespaceAssociationRequest>
  Model::GetCollaborationIdNamespaceAssociationOutcomeCallable GetCollaborationIdNamespaceAssociationCallable(
      const GetCollaborationIdNamespaceAssociationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetCollaborationIdNamespaceAssociation, request);
  }
 
  template <typename GetCollaborationIdNamespaceAssociationRequestT = Model::GetCollaborationIdNamespaceAssociationRequest>
  void GetCollaborationIdNamespaceAssociationAsync(const GetCollaborationIdNamespaceAssociationRequestT& request,
                                                   const GetCollaborationIdNamespaceAssociationResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetCollaborationIdNamespaceAssociation, request, handler, context);
  }
 
  virtual Model::GetCollaborationPrivacyBudgetTemplateOutcome GetCollaborationPrivacyBudgetTemplate(
      const Model::GetCollaborationPrivacyBudgetTemplateRequest& request) const;
 
  template <typename GetCollaborationPrivacyBudgetTemplateRequestT = Model::GetCollaborationPrivacyBudgetTemplateRequest>
  Model::GetCollaborationPrivacyBudgetTemplateOutcomeCallable GetCollaborationPrivacyBudgetTemplateCallable(
      const GetCollaborationPrivacyBudgetTemplateRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetCollaborationPrivacyBudgetTemplate, request);
  }
 
  template <typename GetCollaborationPrivacyBudgetTemplateRequestT = Model::GetCollaborationPrivacyBudgetTemplateRequest>
  void GetCollaborationPrivacyBudgetTemplateAsync(const GetCollaborationPrivacyBudgetTemplateRequestT& request,
                                                  const GetCollaborationPrivacyBudgetTemplateResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetCollaborationPrivacyBudgetTemplate, request, handler, context);
  }
 
  virtual Model::GetConfiguredAudienceModelAssociationOutcome GetConfiguredAudienceModelAssociation(
      const Model::GetConfiguredAudienceModelAssociationRequest& request) const;
 
  template <typename GetConfiguredAudienceModelAssociationRequestT = Model::GetConfiguredAudienceModelAssociationRequest>
  Model::GetConfiguredAudienceModelAssociationOutcomeCallable GetConfiguredAudienceModelAssociationCallable(
      const GetConfiguredAudienceModelAssociationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetConfiguredAudienceModelAssociation, request);
  }
 
  template <typename GetConfiguredAudienceModelAssociationRequestT = Model::GetConfiguredAudienceModelAssociationRequest>
  void GetConfiguredAudienceModelAssociationAsync(const GetConfiguredAudienceModelAssociationRequestT& request,
                                                  const GetConfiguredAudienceModelAssociationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetConfiguredAudienceModelAssociation, request, handler, context);
  }
 
  virtual Model::GetConfiguredTableOutcome GetConfiguredTable(const Model::GetConfiguredTableRequest& request) const;
 
  template <typename GetConfiguredTableRequestT = Model::GetConfiguredTableRequest>
  Model::GetConfiguredTableOutcomeCallable GetConfiguredTableCallable(const GetConfiguredTableRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetConfiguredTable, request);
  }
 
  template <typename GetConfiguredTableRequestT = Model::GetConfiguredTableRequest>
  void GetConfiguredTableAsync(const GetConfiguredTableRequestT& request, const GetConfiguredTableResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetConfiguredTable, request, handler, context);
  }
 
  virtual Model::GetConfiguredTableAnalysisRuleOutcome GetConfiguredTableAnalysisRule(
      const Model::GetConfiguredTableAnalysisRuleRequest& request) const;
 
  template <typename GetConfiguredTableAnalysisRuleRequestT = Model::GetConfiguredTableAnalysisRuleRequest>
  Model::GetConfiguredTableAnalysisRuleOutcomeCallable GetConfiguredTableAnalysisRuleCallable(
      const GetConfiguredTableAnalysisRuleRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetConfiguredTableAnalysisRule, request);
  }
 
  template <typename GetConfiguredTableAnalysisRuleRequestT = Model::GetConfiguredTableAnalysisRuleRequest>
  void GetConfiguredTableAnalysisRuleAsync(const GetConfiguredTableAnalysisRuleRequestT& request,
                                           const GetConfiguredTableAnalysisRuleResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetConfiguredTableAnalysisRule, request, handler, context);
  }
 
  virtual Model::GetConfiguredTableAssociationOutcome GetConfiguredTableAssociation(
      const Model::GetConfiguredTableAssociationRequest& request) const;
 
  template <typename GetConfiguredTableAssociationRequestT = Model::GetConfiguredTableAssociationRequest>
  Model::GetConfiguredTableAssociationOutcomeCallable GetConfiguredTableAssociationCallable(
      const GetConfiguredTableAssociationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetConfiguredTableAssociation, request);
  }
 
  template <typename GetConfiguredTableAssociationRequestT = Model::GetConfiguredTableAssociationRequest>
  void GetConfiguredTableAssociationAsync(const GetConfiguredTableAssociationRequestT& request,
                                          const GetConfiguredTableAssociationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetConfiguredTableAssociation, request, handler, context);
  }
 
  virtual Model::GetConfiguredTableAssociationAnalysisRuleOutcome GetConfiguredTableAssociationAnalysisRule(
      const Model::GetConfiguredTableAssociationAnalysisRuleRequest& request) const;
 
  template <typename GetConfiguredTableAssociationAnalysisRuleRequestT = Model::GetConfiguredTableAssociationAnalysisRuleRequest>
  Model::GetConfiguredTableAssociationAnalysisRuleOutcomeCallable GetConfiguredTableAssociationAnalysisRuleCallable(
      const GetConfiguredTableAssociationAnalysisRuleRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetConfiguredTableAssociationAnalysisRule, request);
  }
 
  template <typename GetConfiguredTableAssociationAnalysisRuleRequestT = Model::GetConfiguredTableAssociationAnalysisRuleRequest>
  void GetConfiguredTableAssociationAnalysisRuleAsync(
      const GetConfiguredTableAssociationAnalysisRuleRequestT& request,
      const GetConfiguredTableAssociationAnalysisRuleResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetConfiguredTableAssociationAnalysisRule, request, handler, context);
  }
 
  virtual Model::GetIdMappingTableOutcome GetIdMappingTable(const Model::GetIdMappingTableRequest& request) const;
 
  template <typename GetIdMappingTableRequestT = Model::GetIdMappingTableRequest>
  Model::GetIdMappingTableOutcomeCallable GetIdMappingTableCallable(const GetIdMappingTableRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetIdMappingTable, request);
  }
 
  template <typename GetIdMappingTableRequestT = Model::GetIdMappingTableRequest>
  void GetIdMappingTableAsync(const GetIdMappingTableRequestT& request, const GetIdMappingTableResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetIdMappingTable, request, handler, context);
  }
 
  virtual Model::GetIdNamespaceAssociationOutcome GetIdNamespaceAssociation(const Model::GetIdNamespaceAssociationRequest& request) const;
 
  template <typename GetIdNamespaceAssociationRequestT = Model::GetIdNamespaceAssociationRequest>
  Model::GetIdNamespaceAssociationOutcomeCallable GetIdNamespaceAssociationCallable(
      const GetIdNamespaceAssociationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetIdNamespaceAssociation, request);
  }
 
  template <typename GetIdNamespaceAssociationRequestT = Model::GetIdNamespaceAssociationRequest>
  void GetIdNamespaceAssociationAsync(const GetIdNamespaceAssociationRequestT& request,
                                      const GetIdNamespaceAssociationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetIdNamespaceAssociation, request, handler, context);
  }
 
  virtual Model::GetIntermediateTableOutcome GetIntermediateTable(const Model::GetIntermediateTableRequest& request) const;
 
  template <typename GetIntermediateTableRequestT = Model::GetIntermediateTableRequest>
  Model::GetIntermediateTableOutcomeCallable GetIntermediateTableCallable(const GetIntermediateTableRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetIntermediateTable, request);
  }
 
  template <typename GetIntermediateTableRequestT = Model::GetIntermediateTableRequest>
  void GetIntermediateTableAsync(const GetIntermediateTableRequestT& request, const GetIntermediateTableResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetIntermediateTable, request, handler, context);
  }
 
  virtual Model::GetIntermediateTableAnalysisRuleOutcome GetIntermediateTableAnalysisRule(
      const Model::GetIntermediateTableAnalysisRuleRequest& request) const;
 
  template <typename GetIntermediateTableAnalysisRuleRequestT = Model::GetIntermediateTableAnalysisRuleRequest>
  Model::GetIntermediateTableAnalysisRuleOutcomeCallable GetIntermediateTableAnalysisRuleCallable(
      const GetIntermediateTableAnalysisRuleRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetIntermediateTableAnalysisRule, request);
  }
 
  template <typename GetIntermediateTableAnalysisRuleRequestT = Model::GetIntermediateTableAnalysisRuleRequest>
  void GetIntermediateTableAnalysisRuleAsync(const GetIntermediateTableAnalysisRuleRequestT& request,
                                             const GetIntermediateTableAnalysisRuleResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetIntermediateTableAnalysisRule, request, handler, context);
  }
 
  virtual Model::GetMembershipOutcome GetMembership(const Model::GetMembershipRequest& request) const;
 
  template <typename GetMembershipRequestT = Model::GetMembershipRequest>
  Model::GetMembershipOutcomeCallable GetMembershipCallable(const GetMembershipRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetMembership, request);
  }
 
  template <typename GetMembershipRequestT = Model::GetMembershipRequest>
  void GetMembershipAsync(const GetMembershipRequestT& request, const GetMembershipResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetMembership, request, handler, context);
  }
 
  virtual Model::GetPrivacyBudgetTemplateOutcome GetPrivacyBudgetTemplate(const Model::GetPrivacyBudgetTemplateRequest& request) const;
 
  template <typename GetPrivacyBudgetTemplateRequestT = Model::GetPrivacyBudgetTemplateRequest>
  Model::GetPrivacyBudgetTemplateOutcomeCallable GetPrivacyBudgetTemplateCallable(const GetPrivacyBudgetTemplateRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetPrivacyBudgetTemplate, request);
  }
 
  template <typename GetPrivacyBudgetTemplateRequestT = Model::GetPrivacyBudgetTemplateRequest>
  void GetPrivacyBudgetTemplateAsync(const GetPrivacyBudgetTemplateRequestT& request,
                                     const GetPrivacyBudgetTemplateResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetPrivacyBudgetTemplate, request, handler, context);
  }
 
  virtual Model::GetProtectedJobOutcome GetProtectedJob(const Model::GetProtectedJobRequest& request) const;
 
  template <typename GetProtectedJobRequestT = Model::GetProtectedJobRequest>
  Model::GetProtectedJobOutcomeCallable GetProtectedJobCallable(const GetProtectedJobRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetProtectedJob, request);
  }
 
  template <typename GetProtectedJobRequestT = Model::GetProtectedJobRequest>
  void GetProtectedJobAsync(const GetProtectedJobRequestT& request, const GetProtectedJobResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetProtectedJob, request, handler, context);
  }
 
  virtual Model::GetProtectedQueryOutcome GetProtectedQuery(const Model::GetProtectedQueryRequest& request) const;
 
  template <typename GetProtectedQueryRequestT = Model::GetProtectedQueryRequest>
  Model::GetProtectedQueryOutcomeCallable GetProtectedQueryCallable(const GetProtectedQueryRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetProtectedQuery, request);
  }
 
  template <typename GetProtectedQueryRequestT = Model::GetProtectedQueryRequest>
  void GetProtectedQueryAsync(const GetProtectedQueryRequestT& request, const GetProtectedQueryResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetProtectedQuery, request, handler, context);
  }
 
  virtual Model::GetSchemaOutcome GetSchema(const Model::GetSchemaRequest& request) const;
 
  template <typename GetSchemaRequestT = Model::GetSchemaRequest>
  Model::GetSchemaOutcomeCallable GetSchemaCallable(const GetSchemaRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetSchema, request);
  }
 
  template <typename GetSchemaRequestT = Model::GetSchemaRequest>
  void GetSchemaAsync(const GetSchemaRequestT& request, const GetSchemaResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetSchema, request, handler, context);
  }
 
  virtual Model::GetSchemaAnalysisRuleOutcome GetSchemaAnalysisRule(const Model::GetSchemaAnalysisRuleRequest& request) const;
 
  template <typename GetSchemaAnalysisRuleRequestT = Model::GetSchemaAnalysisRuleRequest>
  Model::GetSchemaAnalysisRuleOutcomeCallable GetSchemaAnalysisRuleCallable(const GetSchemaAnalysisRuleRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::GetSchemaAnalysisRule, request);
  }
 
  template <typename GetSchemaAnalysisRuleRequestT = Model::GetSchemaAnalysisRuleRequest>
  void GetSchemaAnalysisRuleAsync(const GetSchemaAnalysisRuleRequestT& request, const GetSchemaAnalysisRuleResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::GetSchemaAnalysisRule, request, handler, context);
  }
 
  virtual Model::ListAnalysisLogExportsOutcome ListAnalysisLogExports(const Model::ListAnalysisLogExportsRequest& request) const;
 
  template <typename ListAnalysisLogExportsRequestT = Model::ListAnalysisLogExportsRequest>
  Model::ListAnalysisLogExportsOutcomeCallable ListAnalysisLogExportsCallable(const ListAnalysisLogExportsRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListAnalysisLogExports, request);
  }
 
  template <typename ListAnalysisLogExportsRequestT = Model::ListAnalysisLogExportsRequest>
  void ListAnalysisLogExportsAsync(const ListAnalysisLogExportsRequestT& request,
                                   const ListAnalysisLogExportsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListAnalysisLogExports, request, handler, context);
  }
 
  virtual Model::ListAnalysisTemplatesOutcome ListAnalysisTemplates(const Model::ListAnalysisTemplatesRequest& request) const;
 
  template <typename ListAnalysisTemplatesRequestT = Model::ListAnalysisTemplatesRequest>
  Model::ListAnalysisTemplatesOutcomeCallable ListAnalysisTemplatesCallable(const ListAnalysisTemplatesRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListAnalysisTemplates, request);
  }
 
  template <typename ListAnalysisTemplatesRequestT = Model::ListAnalysisTemplatesRequest>
  void ListAnalysisTemplatesAsync(const ListAnalysisTemplatesRequestT& request, const ListAnalysisTemplatesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListAnalysisTemplates, request, handler, context);
  }
 
  virtual Model::ListCollaborationAnalysisTemplatesOutcome ListCollaborationAnalysisTemplates(
      const Model::ListCollaborationAnalysisTemplatesRequest& request) const;
 
  template <typename ListCollaborationAnalysisTemplatesRequestT = Model::ListCollaborationAnalysisTemplatesRequest>
  Model::ListCollaborationAnalysisTemplatesOutcomeCallable ListCollaborationAnalysisTemplatesCallable(
      const ListCollaborationAnalysisTemplatesRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListCollaborationAnalysisTemplates, request);
  }
 
  template <typename ListCollaborationAnalysisTemplatesRequestT = Model::ListCollaborationAnalysisTemplatesRequest>
  void ListCollaborationAnalysisTemplatesAsync(const ListCollaborationAnalysisTemplatesRequestT& request,
                                               const ListCollaborationAnalysisTemplatesResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListCollaborationAnalysisTemplates, request, handler, context);
  }
 
  virtual Model::ListCollaborationChangeRequestsOutcome ListCollaborationChangeRequests(
      const Model::ListCollaborationChangeRequestsRequest& request) const;
 
  template <typename ListCollaborationChangeRequestsRequestT = Model::ListCollaborationChangeRequestsRequest>
  Model::ListCollaborationChangeRequestsOutcomeCallable ListCollaborationChangeRequestsCallable(
      const ListCollaborationChangeRequestsRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListCollaborationChangeRequests, request);
  }
 
  template <typename ListCollaborationChangeRequestsRequestT = Model::ListCollaborationChangeRequestsRequest>
  void ListCollaborationChangeRequestsAsync(const ListCollaborationChangeRequestsRequestT& request,
                                            const ListCollaborationChangeRequestsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListCollaborationChangeRequests, request, handler, context);
  }
 
  virtual Model::ListCollaborationConfiguredAudienceModelAssociationsOutcome ListCollaborationConfiguredAudienceModelAssociations(
      const Model::ListCollaborationConfiguredAudienceModelAssociationsRequest& request) const;
 
  template <typename ListCollaborationConfiguredAudienceModelAssociationsRequestT =
                Model::ListCollaborationConfiguredAudienceModelAssociationsRequest>
  Model::ListCollaborationConfiguredAudienceModelAssociationsOutcomeCallable ListCollaborationConfiguredAudienceModelAssociationsCallable(
      const ListCollaborationConfiguredAudienceModelAssociationsRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListCollaborationConfiguredAudienceModelAssociations, request);
  }
 
  template <typename ListCollaborationConfiguredAudienceModelAssociationsRequestT =
                Model::ListCollaborationConfiguredAudienceModelAssociationsRequest>
  void ListCollaborationConfiguredAudienceModelAssociationsAsync(
      const ListCollaborationConfiguredAudienceModelAssociationsRequestT& request,
      const ListCollaborationConfiguredAudienceModelAssociationsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListCollaborationConfiguredAudienceModelAssociations, request, handler, context);
  }
 
  virtual Model::ListCollaborationIdNamespaceAssociationsOutcome ListCollaborationIdNamespaceAssociations(
      const Model::ListCollaborationIdNamespaceAssociationsRequest& request) const;
 
  template <typename ListCollaborationIdNamespaceAssociationsRequestT = Model::ListCollaborationIdNamespaceAssociationsRequest>
  Model::ListCollaborationIdNamespaceAssociationsOutcomeCallable ListCollaborationIdNamespaceAssociationsCallable(
      const ListCollaborationIdNamespaceAssociationsRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListCollaborationIdNamespaceAssociations, request);
  }
 
  template <typename ListCollaborationIdNamespaceAssociationsRequestT = Model::ListCollaborationIdNamespaceAssociationsRequest>
  void ListCollaborationIdNamespaceAssociationsAsync(
      const ListCollaborationIdNamespaceAssociationsRequestT& request,
      const ListCollaborationIdNamespaceAssociationsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListCollaborationIdNamespaceAssociations, request, handler, context);
  }
 
  virtual Model::ListCollaborationPrivacyBudgetTemplatesOutcome ListCollaborationPrivacyBudgetTemplates(
      const Model::ListCollaborationPrivacyBudgetTemplatesRequest& request) const;
 
  template <typename ListCollaborationPrivacyBudgetTemplatesRequestT = Model::ListCollaborationPrivacyBudgetTemplatesRequest>
  Model::ListCollaborationPrivacyBudgetTemplatesOutcomeCallable ListCollaborationPrivacyBudgetTemplatesCallable(
      const ListCollaborationPrivacyBudgetTemplatesRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListCollaborationPrivacyBudgetTemplates, request);
  }
 
  template <typename ListCollaborationPrivacyBudgetTemplatesRequestT = Model::ListCollaborationPrivacyBudgetTemplatesRequest>
  void ListCollaborationPrivacyBudgetTemplatesAsync(const ListCollaborationPrivacyBudgetTemplatesRequestT& request,
                                                    const ListCollaborationPrivacyBudgetTemplatesResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListCollaborationPrivacyBudgetTemplates, request, handler, context);
  }
 
  virtual Model::ListCollaborationPrivacyBudgetsOutcome ListCollaborationPrivacyBudgets(
      const Model::ListCollaborationPrivacyBudgetsRequest& request) const;
 
  template <typename ListCollaborationPrivacyBudgetsRequestT = Model::ListCollaborationPrivacyBudgetsRequest>
  Model::ListCollaborationPrivacyBudgetsOutcomeCallable ListCollaborationPrivacyBudgetsCallable(
      const ListCollaborationPrivacyBudgetsRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListCollaborationPrivacyBudgets, request);
  }
 
  template <typename ListCollaborationPrivacyBudgetsRequestT = Model::ListCollaborationPrivacyBudgetsRequest>
  void ListCollaborationPrivacyBudgetsAsync(const ListCollaborationPrivacyBudgetsRequestT& request,
                                            const ListCollaborationPrivacyBudgetsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListCollaborationPrivacyBudgets, request, handler, context);
  }
 
  virtual Model::ListCollaborationsOutcome ListCollaborations(const Model::ListCollaborationsRequest& request = {}) const;
 
  template <typename ListCollaborationsRequestT = Model::ListCollaborationsRequest>
  Model::ListCollaborationsOutcomeCallable ListCollaborationsCallable(const ListCollaborationsRequestT& request = {}) const {
    return SubmitCallable(&CleanRoomsClient::ListCollaborations, request);
  }
 
  template <typename ListCollaborationsRequestT = Model::ListCollaborationsRequest>
  void ListCollaborationsAsync(const ListCollaborationsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListCollaborationsRequestT& request = {}) const {
    return SubmitAsync(&CleanRoomsClient::ListCollaborations, request, handler, context);
  }
 
  virtual Model::ListConfiguredAudienceModelAssociationsOutcome ListConfiguredAudienceModelAssociations(
      const Model::ListConfiguredAudienceModelAssociationsRequest& request) const;
 
  template <typename ListConfiguredAudienceModelAssociationsRequestT = Model::ListConfiguredAudienceModelAssociationsRequest>
  Model::ListConfiguredAudienceModelAssociationsOutcomeCallable ListConfiguredAudienceModelAssociationsCallable(
      const ListConfiguredAudienceModelAssociationsRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListConfiguredAudienceModelAssociations, request);
  }
 
  template <typename ListConfiguredAudienceModelAssociationsRequestT = Model::ListConfiguredAudienceModelAssociationsRequest>
  void ListConfiguredAudienceModelAssociationsAsync(const ListConfiguredAudienceModelAssociationsRequestT& request,
                                                    const ListConfiguredAudienceModelAssociationsResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListConfiguredAudienceModelAssociations, request, handler, context);
  }
 
  virtual Model::ListConfiguredTableAssociationsOutcome ListConfiguredTableAssociations(
      const Model::ListConfiguredTableAssociationsRequest& request) const;
 
  template <typename ListConfiguredTableAssociationsRequestT = Model::ListConfiguredTableAssociationsRequest>
  Model::ListConfiguredTableAssociationsOutcomeCallable ListConfiguredTableAssociationsCallable(
      const ListConfiguredTableAssociationsRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListConfiguredTableAssociations, request);
  }
 
  template <typename ListConfiguredTableAssociationsRequestT = Model::ListConfiguredTableAssociationsRequest>
  void ListConfiguredTableAssociationsAsync(const ListConfiguredTableAssociationsRequestT& request,
                                            const ListConfiguredTableAssociationsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListConfiguredTableAssociations, request, handler, context);
  }
 
  virtual Model::ListConfiguredTablesOutcome ListConfiguredTables(const Model::ListConfiguredTablesRequest& request = {}) const;
 
  template <typename ListConfiguredTablesRequestT = Model::ListConfiguredTablesRequest>
  Model::ListConfiguredTablesOutcomeCallable ListConfiguredTablesCallable(const ListConfiguredTablesRequestT& request = {}) const {
    return SubmitCallable(&CleanRoomsClient::ListConfiguredTables, request);
  }
 
  template <typename ListConfiguredTablesRequestT = Model::ListConfiguredTablesRequest>
  void ListConfiguredTablesAsync(const ListConfiguredTablesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListConfiguredTablesRequestT& request = {}) const {
    return SubmitAsync(&CleanRoomsClient::ListConfiguredTables, request, handler, context);
  }
 
  virtual Model::ListIdMappingTablesOutcome ListIdMappingTables(const Model::ListIdMappingTablesRequest& request) const;
 
  template <typename ListIdMappingTablesRequestT = Model::ListIdMappingTablesRequest>
  Model::ListIdMappingTablesOutcomeCallable ListIdMappingTablesCallable(const ListIdMappingTablesRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListIdMappingTables, request);
  }
 
  template <typename ListIdMappingTablesRequestT = Model::ListIdMappingTablesRequest>
  void ListIdMappingTablesAsync(const ListIdMappingTablesRequestT& request, const ListIdMappingTablesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListIdMappingTables, request, handler, context);
  }
 
  virtual Model::ListIdNamespaceAssociationsOutcome ListIdNamespaceAssociations(
      const Model::ListIdNamespaceAssociationsRequest& request) const;
 
  template <typename ListIdNamespaceAssociationsRequestT = Model::ListIdNamespaceAssociationsRequest>
  Model::ListIdNamespaceAssociationsOutcomeCallable ListIdNamespaceAssociationsCallable(
      const ListIdNamespaceAssociationsRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListIdNamespaceAssociations, request);
  }
 
  template <typename ListIdNamespaceAssociationsRequestT = Model::ListIdNamespaceAssociationsRequest>
  void ListIdNamespaceAssociationsAsync(const ListIdNamespaceAssociationsRequestT& request,
                                        const ListIdNamespaceAssociationsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListIdNamespaceAssociations, request, handler, context);
  }
 
  virtual Model::ListIntermediateTableVersionsOutcome ListIntermediateTableVersions(
      const Model::ListIntermediateTableVersionsRequest& request) const;
 
  template <typename ListIntermediateTableVersionsRequestT = Model::ListIntermediateTableVersionsRequest>
  Model::ListIntermediateTableVersionsOutcomeCallable ListIntermediateTableVersionsCallable(
      const ListIntermediateTableVersionsRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListIntermediateTableVersions, request);
  }
 
  template <typename ListIntermediateTableVersionsRequestT = Model::ListIntermediateTableVersionsRequest>
  void ListIntermediateTableVersionsAsync(const ListIntermediateTableVersionsRequestT& request,
                                          const ListIntermediateTableVersionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListIntermediateTableVersions, request, handler, context);
  }
 
  virtual Model::ListIntermediateTablesOutcome ListIntermediateTables(const Model::ListIntermediateTablesRequest& request) const;
 
  template <typename ListIntermediateTablesRequestT = Model::ListIntermediateTablesRequest>
  Model::ListIntermediateTablesOutcomeCallable ListIntermediateTablesCallable(const ListIntermediateTablesRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListIntermediateTables, request);
  }
 
  template <typename ListIntermediateTablesRequestT = Model::ListIntermediateTablesRequest>
  void ListIntermediateTablesAsync(const ListIntermediateTablesRequestT& request,
                                   const ListIntermediateTablesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListIntermediateTables, request, handler, context);
  }
 
  virtual Model::ListMembersOutcome ListMembers(const Model::ListMembersRequest& request) const;
 
  template <typename ListMembersRequestT = Model::ListMembersRequest>
  Model::ListMembersOutcomeCallable ListMembersCallable(const ListMembersRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListMembers, request);
  }
 
  template <typename ListMembersRequestT = Model::ListMembersRequest>
  void ListMembersAsync(const ListMembersRequestT& request, const ListMembersResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListMembers, request, handler, context);
  }
 
  virtual Model::ListMembershipsOutcome ListMemberships(const Model::ListMembershipsRequest& request = {}) const;
 
  template <typename ListMembershipsRequestT = Model::ListMembershipsRequest>
  Model::ListMembershipsOutcomeCallable ListMembershipsCallable(const ListMembershipsRequestT& request = {}) const {
    return SubmitCallable(&CleanRoomsClient::ListMemberships, request);
  }
 
  template <typename ListMembershipsRequestT = Model::ListMembershipsRequest>
  void ListMembershipsAsync(const ListMembershipsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListMembershipsRequestT& request = {}) const {
    return SubmitAsync(&CleanRoomsClient::ListMemberships, request, handler, context);
  }
 
  virtual Model::ListPrivacyBudgetTemplatesOutcome ListPrivacyBudgetTemplates(
      const Model::ListPrivacyBudgetTemplatesRequest& request) const;
 
  template <typename ListPrivacyBudgetTemplatesRequestT = Model::ListPrivacyBudgetTemplatesRequest>
  Model::ListPrivacyBudgetTemplatesOutcomeCallable ListPrivacyBudgetTemplatesCallable(
      const ListPrivacyBudgetTemplatesRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListPrivacyBudgetTemplates, request);
  }
 
  template <typename ListPrivacyBudgetTemplatesRequestT = Model::ListPrivacyBudgetTemplatesRequest>
  void ListPrivacyBudgetTemplatesAsync(const ListPrivacyBudgetTemplatesRequestT& request,
                                       const ListPrivacyBudgetTemplatesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListPrivacyBudgetTemplates, request, handler, context);
  }
 
  virtual Model::ListPrivacyBudgetsOutcome ListPrivacyBudgets(const Model::ListPrivacyBudgetsRequest& request) const;
 
  template <typename ListPrivacyBudgetsRequestT = Model::ListPrivacyBudgetsRequest>
  Model::ListPrivacyBudgetsOutcomeCallable ListPrivacyBudgetsCallable(const ListPrivacyBudgetsRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListPrivacyBudgets, request);
  }
 
  template <typename ListPrivacyBudgetsRequestT = Model::ListPrivacyBudgetsRequest>
  void ListPrivacyBudgetsAsync(const ListPrivacyBudgetsRequestT& request, const ListPrivacyBudgetsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListPrivacyBudgets, request, handler, context);
  }
 
  virtual Model::ListProtectedJobsOutcome ListProtectedJobs(const Model::ListProtectedJobsRequest& request) const;
 
  template <typename ListProtectedJobsRequestT = Model::ListProtectedJobsRequest>
  Model::ListProtectedJobsOutcomeCallable ListProtectedJobsCallable(const ListProtectedJobsRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListProtectedJobs, request);
  }
 
  template <typename ListProtectedJobsRequestT = Model::ListProtectedJobsRequest>
  void ListProtectedJobsAsync(const ListProtectedJobsRequestT& request, const ListProtectedJobsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListProtectedJobs, request, handler, context);
  }
 
  virtual Model::ListProtectedQueriesOutcome ListProtectedQueries(const Model::ListProtectedQueriesRequest& request) const;
 
  template <typename ListProtectedQueriesRequestT = Model::ListProtectedQueriesRequest>
  Model::ListProtectedQueriesOutcomeCallable ListProtectedQueriesCallable(const ListProtectedQueriesRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListProtectedQueries, request);
  }
 
  template <typename ListProtectedQueriesRequestT = Model::ListProtectedQueriesRequest>
  void ListProtectedQueriesAsync(const ListProtectedQueriesRequestT& request, const ListProtectedQueriesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListProtectedQueries, request, handler, context);
  }
 
  virtual Model::ListSchemasOutcome ListSchemas(const Model::ListSchemasRequest& request) const;
 
  template <typename ListSchemasRequestT = Model::ListSchemasRequest>
  Model::ListSchemasOutcomeCallable ListSchemasCallable(const ListSchemasRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListSchemas, request);
  }
 
  template <typename ListSchemasRequestT = Model::ListSchemasRequest>
  void ListSchemasAsync(const ListSchemasRequestT& request, const ListSchemasResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListSchemas, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PopulateIdMappingTableOutcome PopulateIdMappingTable(const Model::PopulateIdMappingTableRequest& request) const;
 
  template <typename PopulateIdMappingTableRequestT = Model::PopulateIdMappingTableRequest>
  Model::PopulateIdMappingTableOutcomeCallable PopulateIdMappingTableCallable(const PopulateIdMappingTableRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::PopulateIdMappingTable, request);
  }
 
  template <typename PopulateIdMappingTableRequestT = Model::PopulateIdMappingTableRequest>
  void PopulateIdMappingTableAsync(const PopulateIdMappingTableRequestT& request,
                                   const PopulateIdMappingTableResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::PopulateIdMappingTable, request, handler, context);
  }
 
  virtual Model::PopulateIntermediateTableOutcome PopulateIntermediateTable(const Model::PopulateIntermediateTableRequest& request) const;
 
  template <typename PopulateIntermediateTableRequestT = Model::PopulateIntermediateTableRequest>
  Model::PopulateIntermediateTableOutcomeCallable PopulateIntermediateTableCallable(
      const PopulateIntermediateTableRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::PopulateIntermediateTable, request);
  }
 
  template <typename PopulateIntermediateTableRequestT = Model::PopulateIntermediateTableRequest>
  void PopulateIntermediateTableAsync(const PopulateIntermediateTableRequestT& request,
                                      const PopulateIntermediateTableResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::PopulateIntermediateTable, request, handler, context);
  }
 
  virtual Model::PreviewPrivacyImpactOutcome PreviewPrivacyImpact(const Model::PreviewPrivacyImpactRequest& request) const;
 
  template <typename PreviewPrivacyImpactRequestT = Model::PreviewPrivacyImpactRequest>
  Model::PreviewPrivacyImpactOutcomeCallable PreviewPrivacyImpactCallable(const PreviewPrivacyImpactRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::PreviewPrivacyImpact, request);
  }
 
  template <typename PreviewPrivacyImpactRequestT = Model::PreviewPrivacyImpactRequest>
  void PreviewPrivacyImpactAsync(const PreviewPrivacyImpactRequestT& request, const PreviewPrivacyImpactResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::PreviewPrivacyImpact, request, handler, context);
  }
 
  virtual Model::StartAnalysisLogExportOutcome StartAnalysisLogExport(const Model::StartAnalysisLogExportRequest& request) const;
 
  template <typename StartAnalysisLogExportRequestT = Model::StartAnalysisLogExportRequest>
  Model::StartAnalysisLogExportOutcomeCallable StartAnalysisLogExportCallable(const StartAnalysisLogExportRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::StartAnalysisLogExport, request);
  }
 
  template <typename StartAnalysisLogExportRequestT = Model::StartAnalysisLogExportRequest>
  void StartAnalysisLogExportAsync(const StartAnalysisLogExportRequestT& request,
                                   const StartAnalysisLogExportResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::StartAnalysisLogExport, request, handler, context);
  }
 
  virtual Model::StartProtectedJobOutcome StartProtectedJob(const Model::StartProtectedJobRequest& request) const;
 
  template <typename StartProtectedJobRequestT = Model::StartProtectedJobRequest>
  Model::StartProtectedJobOutcomeCallable StartProtectedJobCallable(const StartProtectedJobRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::StartProtectedJob, request);
  }
 
  template <typename StartProtectedJobRequestT = Model::StartProtectedJobRequest>
  void StartProtectedJobAsync(const StartProtectedJobRequestT& request, const StartProtectedJobResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::StartProtectedJob, request, handler, context);
  }
 
  virtual Model::StartProtectedQueryOutcome StartProtectedQuery(const Model::StartProtectedQueryRequest& request) const;
 
  template <typename StartProtectedQueryRequestT = Model::StartProtectedQueryRequest>
  Model::StartProtectedQueryOutcomeCallable StartProtectedQueryCallable(const StartProtectedQueryRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::StartProtectedQuery, request);
  }
 
  template <typename StartProtectedQueryRequestT = Model::StartProtectedQueryRequest>
  void StartProtectedQueryAsync(const StartProtectedQueryRequestT& request, const StartProtectedQueryResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::StartProtectedQuery, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAnalysisTemplateOutcome UpdateAnalysisTemplate(const Model::UpdateAnalysisTemplateRequest& request) const;
 
  template <typename UpdateAnalysisTemplateRequestT = Model::UpdateAnalysisTemplateRequest>
  Model::UpdateAnalysisTemplateOutcomeCallable UpdateAnalysisTemplateCallable(const UpdateAnalysisTemplateRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UpdateAnalysisTemplate, request);
  }
 
  template <typename UpdateAnalysisTemplateRequestT = Model::UpdateAnalysisTemplateRequest>
  void UpdateAnalysisTemplateAsync(const UpdateAnalysisTemplateRequestT& request,
                                   const UpdateAnalysisTemplateResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UpdateAnalysisTemplate, request, handler, context);
  }
 
  virtual Model::UpdateCollaborationOutcome UpdateCollaboration(const Model::UpdateCollaborationRequest& request) const;
 
  template <typename UpdateCollaborationRequestT = Model::UpdateCollaborationRequest>
  Model::UpdateCollaborationOutcomeCallable UpdateCollaborationCallable(const UpdateCollaborationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UpdateCollaboration, request);
  }
 
  template <typename UpdateCollaborationRequestT = Model::UpdateCollaborationRequest>
  void UpdateCollaborationAsync(const UpdateCollaborationRequestT& request, const UpdateCollaborationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UpdateCollaboration, request, handler, context);
  }
 
  virtual Model::UpdateCollaborationChangeRequestOutcome UpdateCollaborationChangeRequest(
      const Model::UpdateCollaborationChangeRequestRequest& request) const;
 
  template <typename UpdateCollaborationChangeRequestRequestT = Model::UpdateCollaborationChangeRequestRequest>
  Model::UpdateCollaborationChangeRequestOutcomeCallable UpdateCollaborationChangeRequestCallable(
      const UpdateCollaborationChangeRequestRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UpdateCollaborationChangeRequest, request);
  }
 
  template <typename UpdateCollaborationChangeRequestRequestT = Model::UpdateCollaborationChangeRequestRequest>
  void UpdateCollaborationChangeRequestAsync(const UpdateCollaborationChangeRequestRequestT& request,
                                             const UpdateCollaborationChangeRequestResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UpdateCollaborationChangeRequest, request, handler, context);
  }
 
  virtual Model::UpdateConfiguredAudienceModelAssociationOutcome UpdateConfiguredAudienceModelAssociation(
      const Model::UpdateConfiguredAudienceModelAssociationRequest& request) const;
 
  template <typename UpdateConfiguredAudienceModelAssociationRequestT = Model::UpdateConfiguredAudienceModelAssociationRequest>
  Model::UpdateConfiguredAudienceModelAssociationOutcomeCallable UpdateConfiguredAudienceModelAssociationCallable(
      const UpdateConfiguredAudienceModelAssociationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UpdateConfiguredAudienceModelAssociation, request);
  }
 
  template <typename UpdateConfiguredAudienceModelAssociationRequestT = Model::UpdateConfiguredAudienceModelAssociationRequest>
  void UpdateConfiguredAudienceModelAssociationAsync(
      const UpdateConfiguredAudienceModelAssociationRequestT& request,
      const UpdateConfiguredAudienceModelAssociationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UpdateConfiguredAudienceModelAssociation, request, handler, context);
  }
 
  virtual Model::UpdateConfiguredTableOutcome UpdateConfiguredTable(const Model::UpdateConfiguredTableRequest& request) const;
 
  template <typename UpdateConfiguredTableRequestT = Model::UpdateConfiguredTableRequest>
  Model::UpdateConfiguredTableOutcomeCallable UpdateConfiguredTableCallable(const UpdateConfiguredTableRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UpdateConfiguredTable, request);
  }
 
  template <typename UpdateConfiguredTableRequestT = Model::UpdateConfiguredTableRequest>
  void UpdateConfiguredTableAsync(const UpdateConfiguredTableRequestT& request, const UpdateConfiguredTableResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UpdateConfiguredTable, request, handler, context);
  }
 
  virtual Model::UpdateConfiguredTableAnalysisRuleOutcome UpdateConfiguredTableAnalysisRule(
      const Model::UpdateConfiguredTableAnalysisRuleRequest& request) const;
 
  template <typename UpdateConfiguredTableAnalysisRuleRequestT = Model::UpdateConfiguredTableAnalysisRuleRequest>
  Model::UpdateConfiguredTableAnalysisRuleOutcomeCallable UpdateConfiguredTableAnalysisRuleCallable(
      const UpdateConfiguredTableAnalysisRuleRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UpdateConfiguredTableAnalysisRule, request);
  }
 
  template <typename UpdateConfiguredTableAnalysisRuleRequestT = Model::UpdateConfiguredTableAnalysisRuleRequest>
  void UpdateConfiguredTableAnalysisRuleAsync(const UpdateConfiguredTableAnalysisRuleRequestT& request,
                                              const UpdateConfiguredTableAnalysisRuleResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UpdateConfiguredTableAnalysisRule, request, handler, context);
  }
 
  virtual Model::UpdateConfiguredTableAssociationOutcome UpdateConfiguredTableAssociation(
      const Model::UpdateConfiguredTableAssociationRequest& request) const;
 
  template <typename UpdateConfiguredTableAssociationRequestT = Model::UpdateConfiguredTableAssociationRequest>
  Model::UpdateConfiguredTableAssociationOutcomeCallable UpdateConfiguredTableAssociationCallable(
      const UpdateConfiguredTableAssociationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UpdateConfiguredTableAssociation, request);
  }
 
  template <typename UpdateConfiguredTableAssociationRequestT = Model::UpdateConfiguredTableAssociationRequest>
  void UpdateConfiguredTableAssociationAsync(const UpdateConfiguredTableAssociationRequestT& request,
                                             const UpdateConfiguredTableAssociationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UpdateConfiguredTableAssociation, request, handler, context);
  }
 
  virtual Model::UpdateConfiguredTableAssociationAnalysisRuleOutcome UpdateConfiguredTableAssociationAnalysisRule(
      const Model::UpdateConfiguredTableAssociationAnalysisRuleRequest& request) const;
 
  template <typename UpdateConfiguredTableAssociationAnalysisRuleRequestT = Model::UpdateConfiguredTableAssociationAnalysisRuleRequest>
  Model::UpdateConfiguredTableAssociationAnalysisRuleOutcomeCallable UpdateConfiguredTableAssociationAnalysisRuleCallable(
      const UpdateConfiguredTableAssociationAnalysisRuleRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UpdateConfiguredTableAssociationAnalysisRule, request);
  }
 
  template <typename UpdateConfiguredTableAssociationAnalysisRuleRequestT = Model::UpdateConfiguredTableAssociationAnalysisRuleRequest>
  void UpdateConfiguredTableAssociationAnalysisRuleAsync(
      const UpdateConfiguredTableAssociationAnalysisRuleRequestT& request,
      const UpdateConfiguredTableAssociationAnalysisRuleResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UpdateConfiguredTableAssociationAnalysisRule, request, handler, context);
  }
 
  virtual Model::UpdateIdMappingTableOutcome UpdateIdMappingTable(const Model::UpdateIdMappingTableRequest& request) const;
 
  template <typename UpdateIdMappingTableRequestT = Model::UpdateIdMappingTableRequest>
  Model::UpdateIdMappingTableOutcomeCallable UpdateIdMappingTableCallable(const UpdateIdMappingTableRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UpdateIdMappingTable, request);
  }
 
  template <typename UpdateIdMappingTableRequestT = Model::UpdateIdMappingTableRequest>
  void UpdateIdMappingTableAsync(const UpdateIdMappingTableRequestT& request, const UpdateIdMappingTableResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UpdateIdMappingTable, request, handler, context);
  }
 
  virtual Model::UpdateIdNamespaceAssociationOutcome UpdateIdNamespaceAssociation(
      const Model::UpdateIdNamespaceAssociationRequest& request) const;
 
  template <typename UpdateIdNamespaceAssociationRequestT = Model::UpdateIdNamespaceAssociationRequest>
  Model::UpdateIdNamespaceAssociationOutcomeCallable UpdateIdNamespaceAssociationCallable(
      const UpdateIdNamespaceAssociationRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UpdateIdNamespaceAssociation, request);
  }
 
  template <typename UpdateIdNamespaceAssociationRequestT = Model::UpdateIdNamespaceAssociationRequest>
  void UpdateIdNamespaceAssociationAsync(const UpdateIdNamespaceAssociationRequestT& request,
                                         const UpdateIdNamespaceAssociationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UpdateIdNamespaceAssociation, request, handler, context);
  }
 
  virtual Model::UpdateIntermediateTableOutcome UpdateIntermediateTable(const Model::UpdateIntermediateTableRequest& request) const;
 
  template <typename UpdateIntermediateTableRequestT = Model::UpdateIntermediateTableRequest>
  Model::UpdateIntermediateTableOutcomeCallable UpdateIntermediateTableCallable(const UpdateIntermediateTableRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UpdateIntermediateTable, request);
  }
 
  template <typename UpdateIntermediateTableRequestT = Model::UpdateIntermediateTableRequest>
  void UpdateIntermediateTableAsync(const UpdateIntermediateTableRequestT& request,
                                    const UpdateIntermediateTableResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UpdateIntermediateTable, request, handler, context);
  }
 
  virtual Model::UpdateIntermediateTableAnalysisRuleOutcome UpdateIntermediateTableAnalysisRule(
      const Model::UpdateIntermediateTableAnalysisRuleRequest& request) const;
 
  template <typename UpdateIntermediateTableAnalysisRuleRequestT = Model::UpdateIntermediateTableAnalysisRuleRequest>
  Model::UpdateIntermediateTableAnalysisRuleOutcomeCallable UpdateIntermediateTableAnalysisRuleCallable(
      const UpdateIntermediateTableAnalysisRuleRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UpdateIntermediateTableAnalysisRule, request);
  }
 
  template <typename UpdateIntermediateTableAnalysisRuleRequestT = Model::UpdateIntermediateTableAnalysisRuleRequest>
  void UpdateIntermediateTableAnalysisRuleAsync(const UpdateIntermediateTableAnalysisRuleRequestT& request,
                                                const UpdateIntermediateTableAnalysisRuleResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UpdateIntermediateTableAnalysisRule, request, handler, context);
  }
 
  virtual Model::UpdateMembershipOutcome UpdateMembership(const Model::UpdateMembershipRequest& request) const;
 
  template <typename UpdateMembershipRequestT = Model::UpdateMembershipRequest>
  Model::UpdateMembershipOutcomeCallable UpdateMembershipCallable(const UpdateMembershipRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UpdateMembership, request);
  }
 
  template <typename UpdateMembershipRequestT = Model::UpdateMembershipRequest>
  void UpdateMembershipAsync(const UpdateMembershipRequestT& request, const UpdateMembershipResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UpdateMembership, request, handler, context);
  }
 
  virtual Model::UpdatePrivacyBudgetTemplateOutcome UpdatePrivacyBudgetTemplate(
      const Model::UpdatePrivacyBudgetTemplateRequest& request) const;
 
  template <typename UpdatePrivacyBudgetTemplateRequestT = Model::UpdatePrivacyBudgetTemplateRequest>
  Model::UpdatePrivacyBudgetTemplateOutcomeCallable UpdatePrivacyBudgetTemplateCallable(
      const UpdatePrivacyBudgetTemplateRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UpdatePrivacyBudgetTemplate, request);
  }
 
  template <typename UpdatePrivacyBudgetTemplateRequestT = Model::UpdatePrivacyBudgetTemplateRequest>
  void UpdatePrivacyBudgetTemplateAsync(const UpdatePrivacyBudgetTemplateRequestT& request,
                                        const UpdatePrivacyBudgetTemplateResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UpdatePrivacyBudgetTemplate, request, handler, context);
  }
 
  virtual Model::UpdateProtectedJobOutcome UpdateProtectedJob(const Model::UpdateProtectedJobRequest& request) const;
 
  template <typename UpdateProtectedJobRequestT = Model::UpdateProtectedJobRequest>
  Model::UpdateProtectedJobOutcomeCallable UpdateProtectedJobCallable(const UpdateProtectedJobRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UpdateProtectedJob, request);
  }
 
  template <typename UpdateProtectedJobRequestT = Model::UpdateProtectedJobRequest>
  void UpdateProtectedJobAsync(const UpdateProtectedJobRequestT& request, const UpdateProtectedJobResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UpdateProtectedJob, request, handler, context);
  }
 
  virtual Model::UpdateProtectedQueryOutcome UpdateProtectedQuery(const Model::UpdateProtectedQueryRequest& request) const;
 
  template <typename UpdateProtectedQueryRequestT = Model::UpdateProtectedQueryRequest>
  Model::UpdateProtectedQueryOutcomeCallable UpdateProtectedQueryCallable(const UpdateProtectedQueryRequestT& request) const {
    return SubmitCallable(&CleanRoomsClient::UpdateProtectedQuery, request);
  }
 
  template <typename UpdateProtectedQueryRequestT = Model::UpdateProtectedQueryRequest>
  void UpdateProtectedQueryAsync(const UpdateProtectedQueryRequestT& request, const UpdateProtectedQueryResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CleanRoomsClient::UpdateProtectedQuery, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<CleanRoomsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CleanRoomsClient>;
  void init(const CleanRoomsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, CleanRoomsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  CleanRoomsClientConfiguration m_clientConfiguration;
  std::shared_ptr<CleanRoomsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CleanRooms
}  // namespace Aws