CleanRoomsClient.h

 
#pragma once
#include <aws/cleanrooms/CleanRooms_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/cleanrooms/CleanRoomsServiceClientModel.h>
 
namespace Aws
{
namespace CleanRooms
{
  class AWS_CLEANROOMS_API CleanRoomsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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::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::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::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::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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CleanRoomsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CleanRoomsClient>;
      void init(const CleanRoomsClientConfiguration& clientConfiguration);
 
      CleanRoomsClientConfiguration m_clientConfiguration;
      std::shared_ptr<CleanRoomsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CleanRooms
} // namespace Aws