CleanRoomsMLClient.h

 
#pragma once
#include <aws/cleanroomsml/CleanRoomsML_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/cleanroomsml/CleanRoomsMLServiceClientModel.h>
 
namespace Aws
{
namespace CleanRoomsML
{
  class AWS_CLEANROOMSML_API CleanRoomsMLClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<CleanRoomsMLClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef CleanRoomsMLClientConfiguration ClientConfigurationType;
      typedef CleanRoomsMLEndpointProvider EndpointProviderType;
 
        CleanRoomsMLClient(const Aws::CleanRoomsML::CleanRoomsMLClientConfiguration& clientConfiguration = Aws::CleanRoomsML::CleanRoomsMLClientConfiguration(),
                           std::shared_ptr<CleanRoomsMLEndpointProviderBase> endpointProvider = nullptr);
 
        CleanRoomsMLClient(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<CleanRoomsMLEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::CleanRoomsML::CleanRoomsMLClientConfiguration& clientConfiguration = Aws::CleanRoomsML::CleanRoomsMLClientConfiguration());
 
        CleanRoomsMLClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<CleanRoomsMLEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::CleanRoomsML::CleanRoomsMLClientConfiguration& clientConfiguration = Aws::CleanRoomsML::CleanRoomsMLClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        CleanRoomsMLClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CleanRoomsMLClient(const Aws::Auth::AWSCredentials& credentials,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CleanRoomsMLClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~CleanRoomsMLClient();
 
        virtual Model::CreateAudienceModelOutcome CreateAudienceModel(const Model::CreateAudienceModelRequest& request) const;
 
        template<typename CreateAudienceModelRequestT = Model::CreateAudienceModelRequest>
        Model::CreateAudienceModelOutcomeCallable CreateAudienceModelCallable(const CreateAudienceModelRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::CreateAudienceModel, request);
        }
 
        template<typename CreateAudienceModelRequestT = Model::CreateAudienceModelRequest>
        void CreateAudienceModelAsync(const CreateAudienceModelRequestT& request, const CreateAudienceModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::CreateAudienceModel, request, handler, context);
        }
 
        virtual Model::CreateConfiguredAudienceModelOutcome CreateConfiguredAudienceModel(const Model::CreateConfiguredAudienceModelRequest& request) const;
 
        template<typename CreateConfiguredAudienceModelRequestT = Model::CreateConfiguredAudienceModelRequest>
        Model::CreateConfiguredAudienceModelOutcomeCallable CreateConfiguredAudienceModelCallable(const CreateConfiguredAudienceModelRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::CreateConfiguredAudienceModel, request);
        }
 
        template<typename CreateConfiguredAudienceModelRequestT = Model::CreateConfiguredAudienceModelRequest>
        void CreateConfiguredAudienceModelAsync(const CreateConfiguredAudienceModelRequestT& request, const CreateConfiguredAudienceModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::CreateConfiguredAudienceModel, request, handler, context);
        }
 
        virtual Model::CreateTrainingDatasetOutcome CreateTrainingDataset(const Model::CreateTrainingDatasetRequest& request) const;
 
        template<typename CreateTrainingDatasetRequestT = Model::CreateTrainingDatasetRequest>
        Model::CreateTrainingDatasetOutcomeCallable CreateTrainingDatasetCallable(const CreateTrainingDatasetRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::CreateTrainingDataset, request);
        }
 
        template<typename CreateTrainingDatasetRequestT = Model::CreateTrainingDatasetRequest>
        void CreateTrainingDatasetAsync(const CreateTrainingDatasetRequestT& request, const CreateTrainingDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::CreateTrainingDataset, request, handler, context);
        }
 
        virtual Model::DeleteAudienceGenerationJobOutcome DeleteAudienceGenerationJob(const Model::DeleteAudienceGenerationJobRequest& request) const;
 
        template<typename DeleteAudienceGenerationJobRequestT = Model::DeleteAudienceGenerationJobRequest>
        Model::DeleteAudienceGenerationJobOutcomeCallable DeleteAudienceGenerationJobCallable(const DeleteAudienceGenerationJobRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::DeleteAudienceGenerationJob, request);
        }
 
        template<typename DeleteAudienceGenerationJobRequestT = Model::DeleteAudienceGenerationJobRequest>
        void DeleteAudienceGenerationJobAsync(const DeleteAudienceGenerationJobRequestT& request, const DeleteAudienceGenerationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::DeleteAudienceGenerationJob, request, handler, context);
        }
 
        virtual Model::DeleteAudienceModelOutcome DeleteAudienceModel(const Model::DeleteAudienceModelRequest& request) const;
 
        template<typename DeleteAudienceModelRequestT = Model::DeleteAudienceModelRequest>
        Model::DeleteAudienceModelOutcomeCallable DeleteAudienceModelCallable(const DeleteAudienceModelRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::DeleteAudienceModel, request);
        }
 
        template<typename DeleteAudienceModelRequestT = Model::DeleteAudienceModelRequest>
        void DeleteAudienceModelAsync(const DeleteAudienceModelRequestT& request, const DeleteAudienceModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::DeleteAudienceModel, request, handler, context);
        }
 
        virtual Model::DeleteConfiguredAudienceModelOutcome DeleteConfiguredAudienceModel(const Model::DeleteConfiguredAudienceModelRequest& request) const;
 
        template<typename DeleteConfiguredAudienceModelRequestT = Model::DeleteConfiguredAudienceModelRequest>
        Model::DeleteConfiguredAudienceModelOutcomeCallable DeleteConfiguredAudienceModelCallable(const DeleteConfiguredAudienceModelRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::DeleteConfiguredAudienceModel, request);
        }
 
        template<typename DeleteConfiguredAudienceModelRequestT = Model::DeleteConfiguredAudienceModelRequest>
        void DeleteConfiguredAudienceModelAsync(const DeleteConfiguredAudienceModelRequestT& request, const DeleteConfiguredAudienceModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::DeleteConfiguredAudienceModel, request, handler, context);
        }
 
        virtual Model::DeleteConfiguredAudienceModelPolicyOutcome DeleteConfiguredAudienceModelPolicy(const Model::DeleteConfiguredAudienceModelPolicyRequest& request) const;
 
        template<typename DeleteConfiguredAudienceModelPolicyRequestT = Model::DeleteConfiguredAudienceModelPolicyRequest>
        Model::DeleteConfiguredAudienceModelPolicyOutcomeCallable DeleteConfiguredAudienceModelPolicyCallable(const DeleteConfiguredAudienceModelPolicyRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::DeleteConfiguredAudienceModelPolicy, request);
        }
 
        template<typename DeleteConfiguredAudienceModelPolicyRequestT = Model::DeleteConfiguredAudienceModelPolicyRequest>
        void DeleteConfiguredAudienceModelPolicyAsync(const DeleteConfiguredAudienceModelPolicyRequestT& request, const DeleteConfiguredAudienceModelPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::DeleteConfiguredAudienceModelPolicy, request, handler, context);
        }
 
        virtual Model::DeleteTrainingDatasetOutcome DeleteTrainingDataset(const Model::DeleteTrainingDatasetRequest& request) const;
 
        template<typename DeleteTrainingDatasetRequestT = Model::DeleteTrainingDatasetRequest>
        Model::DeleteTrainingDatasetOutcomeCallable DeleteTrainingDatasetCallable(const DeleteTrainingDatasetRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::DeleteTrainingDataset, request);
        }
 
        template<typename DeleteTrainingDatasetRequestT = Model::DeleteTrainingDatasetRequest>
        void DeleteTrainingDatasetAsync(const DeleteTrainingDatasetRequestT& request, const DeleteTrainingDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::DeleteTrainingDataset, request, handler, context);
        }
 
        virtual Model::GetAudienceGenerationJobOutcome GetAudienceGenerationJob(const Model::GetAudienceGenerationJobRequest& request) const;
 
        template<typename GetAudienceGenerationJobRequestT = Model::GetAudienceGenerationJobRequest>
        Model::GetAudienceGenerationJobOutcomeCallable GetAudienceGenerationJobCallable(const GetAudienceGenerationJobRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::GetAudienceGenerationJob, request);
        }
 
        template<typename GetAudienceGenerationJobRequestT = Model::GetAudienceGenerationJobRequest>
        void GetAudienceGenerationJobAsync(const GetAudienceGenerationJobRequestT& request, const GetAudienceGenerationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::GetAudienceGenerationJob, request, handler, context);
        }
 
        virtual Model::GetAudienceModelOutcome GetAudienceModel(const Model::GetAudienceModelRequest& request) const;
 
        template<typename GetAudienceModelRequestT = Model::GetAudienceModelRequest>
        Model::GetAudienceModelOutcomeCallable GetAudienceModelCallable(const GetAudienceModelRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::GetAudienceModel, request);
        }
 
        template<typename GetAudienceModelRequestT = Model::GetAudienceModelRequest>
        void GetAudienceModelAsync(const GetAudienceModelRequestT& request, const GetAudienceModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::GetAudienceModel, request, handler, context);
        }
 
        virtual Model::GetConfiguredAudienceModelOutcome GetConfiguredAudienceModel(const Model::GetConfiguredAudienceModelRequest& request) const;
 
        template<typename GetConfiguredAudienceModelRequestT = Model::GetConfiguredAudienceModelRequest>
        Model::GetConfiguredAudienceModelOutcomeCallable GetConfiguredAudienceModelCallable(const GetConfiguredAudienceModelRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::GetConfiguredAudienceModel, request);
        }
 
        template<typename GetConfiguredAudienceModelRequestT = Model::GetConfiguredAudienceModelRequest>
        void GetConfiguredAudienceModelAsync(const GetConfiguredAudienceModelRequestT& request, const GetConfiguredAudienceModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::GetConfiguredAudienceModel, request, handler, context);
        }
 
        virtual Model::GetConfiguredAudienceModelPolicyOutcome GetConfiguredAudienceModelPolicy(const Model::GetConfiguredAudienceModelPolicyRequest& request) const;
 
        template<typename GetConfiguredAudienceModelPolicyRequestT = Model::GetConfiguredAudienceModelPolicyRequest>
        Model::GetConfiguredAudienceModelPolicyOutcomeCallable GetConfiguredAudienceModelPolicyCallable(const GetConfiguredAudienceModelPolicyRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::GetConfiguredAudienceModelPolicy, request);
        }
 
        template<typename GetConfiguredAudienceModelPolicyRequestT = Model::GetConfiguredAudienceModelPolicyRequest>
        void GetConfiguredAudienceModelPolicyAsync(const GetConfiguredAudienceModelPolicyRequestT& request, const GetConfiguredAudienceModelPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::GetConfiguredAudienceModelPolicy, request, handler, context);
        }
 
        virtual Model::GetTrainingDatasetOutcome GetTrainingDataset(const Model::GetTrainingDatasetRequest& request) const;
 
        template<typename GetTrainingDatasetRequestT = Model::GetTrainingDatasetRequest>
        Model::GetTrainingDatasetOutcomeCallable GetTrainingDatasetCallable(const GetTrainingDatasetRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::GetTrainingDataset, request);
        }
 
        template<typename GetTrainingDatasetRequestT = Model::GetTrainingDatasetRequest>
        void GetTrainingDatasetAsync(const GetTrainingDatasetRequestT& request, const GetTrainingDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::GetTrainingDataset, request, handler, context);
        }
 
        virtual Model::ListAudienceExportJobsOutcome ListAudienceExportJobs(const Model::ListAudienceExportJobsRequest& request = {}) const;
 
        template<typename ListAudienceExportJobsRequestT = Model::ListAudienceExportJobsRequest>
        Model::ListAudienceExportJobsOutcomeCallable ListAudienceExportJobsCallable(const ListAudienceExportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&CleanRoomsMLClient::ListAudienceExportJobs, request);
        }
 
        template<typename ListAudienceExportJobsRequestT = Model::ListAudienceExportJobsRequest>
        void ListAudienceExportJobsAsync(const ListAudienceExportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAudienceExportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&CleanRoomsMLClient::ListAudienceExportJobs, request, handler, context);
        }
 
        virtual Model::ListAudienceGenerationJobsOutcome ListAudienceGenerationJobs(const Model::ListAudienceGenerationJobsRequest& request = {}) const;
 
        template<typename ListAudienceGenerationJobsRequestT = Model::ListAudienceGenerationJobsRequest>
        Model::ListAudienceGenerationJobsOutcomeCallable ListAudienceGenerationJobsCallable(const ListAudienceGenerationJobsRequestT& request = {}) const
        {
            return SubmitCallable(&CleanRoomsMLClient::ListAudienceGenerationJobs, request);
        }
 
        template<typename ListAudienceGenerationJobsRequestT = Model::ListAudienceGenerationJobsRequest>
        void ListAudienceGenerationJobsAsync(const ListAudienceGenerationJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAudienceGenerationJobsRequestT& request = {}) const
        {
            return SubmitAsync(&CleanRoomsMLClient::ListAudienceGenerationJobs, request, handler, context);
        }
 
        virtual Model::ListAudienceModelsOutcome ListAudienceModels(const Model::ListAudienceModelsRequest& request = {}) const;
 
        template<typename ListAudienceModelsRequestT = Model::ListAudienceModelsRequest>
        Model::ListAudienceModelsOutcomeCallable ListAudienceModelsCallable(const ListAudienceModelsRequestT& request = {}) const
        {
            return SubmitCallable(&CleanRoomsMLClient::ListAudienceModels, request);
        }
 
        template<typename ListAudienceModelsRequestT = Model::ListAudienceModelsRequest>
        void ListAudienceModelsAsync(const ListAudienceModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAudienceModelsRequestT& request = {}) const
        {
            return SubmitAsync(&CleanRoomsMLClient::ListAudienceModels, request, handler, context);
        }
 
        virtual Model::ListConfiguredAudienceModelsOutcome ListConfiguredAudienceModels(const Model::ListConfiguredAudienceModelsRequest& request = {}) const;
 
        template<typename ListConfiguredAudienceModelsRequestT = Model::ListConfiguredAudienceModelsRequest>
        Model::ListConfiguredAudienceModelsOutcomeCallable ListConfiguredAudienceModelsCallable(const ListConfiguredAudienceModelsRequestT& request = {}) const
        {
            return SubmitCallable(&CleanRoomsMLClient::ListConfiguredAudienceModels, request);
        }
 
        template<typename ListConfiguredAudienceModelsRequestT = Model::ListConfiguredAudienceModelsRequest>
        void ListConfiguredAudienceModelsAsync(const ListConfiguredAudienceModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListConfiguredAudienceModelsRequestT& request = {}) const
        {
            return SubmitAsync(&CleanRoomsMLClient::ListConfiguredAudienceModels, 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(&CleanRoomsMLClient::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(&CleanRoomsMLClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTrainingDatasetsOutcome ListTrainingDatasets(const Model::ListTrainingDatasetsRequest& request = {}) const;
 
        template<typename ListTrainingDatasetsRequestT = Model::ListTrainingDatasetsRequest>
        Model::ListTrainingDatasetsOutcomeCallable ListTrainingDatasetsCallable(const ListTrainingDatasetsRequestT& request = {}) const
        {
            return SubmitCallable(&CleanRoomsMLClient::ListTrainingDatasets, request);
        }
 
        template<typename ListTrainingDatasetsRequestT = Model::ListTrainingDatasetsRequest>
        void ListTrainingDatasetsAsync(const ListTrainingDatasetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTrainingDatasetsRequestT& request = {}) const
        {
            return SubmitAsync(&CleanRoomsMLClient::ListTrainingDatasets, request, handler, context);
        }
 
        virtual Model::PutConfiguredAudienceModelPolicyOutcome PutConfiguredAudienceModelPolicy(const Model::PutConfiguredAudienceModelPolicyRequest& request) const;
 
        template<typename PutConfiguredAudienceModelPolicyRequestT = Model::PutConfiguredAudienceModelPolicyRequest>
        Model::PutConfiguredAudienceModelPolicyOutcomeCallable PutConfiguredAudienceModelPolicyCallable(const PutConfiguredAudienceModelPolicyRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::PutConfiguredAudienceModelPolicy, request);
        }
 
        template<typename PutConfiguredAudienceModelPolicyRequestT = Model::PutConfiguredAudienceModelPolicyRequest>
        void PutConfiguredAudienceModelPolicyAsync(const PutConfiguredAudienceModelPolicyRequestT& request, const PutConfiguredAudienceModelPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::PutConfiguredAudienceModelPolicy, request, handler, context);
        }
 
        virtual Model::StartAudienceExportJobOutcome StartAudienceExportJob(const Model::StartAudienceExportJobRequest& request) const;
 
        template<typename StartAudienceExportJobRequestT = Model::StartAudienceExportJobRequest>
        Model::StartAudienceExportJobOutcomeCallable StartAudienceExportJobCallable(const StartAudienceExportJobRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::StartAudienceExportJob, request);
        }
 
        template<typename StartAudienceExportJobRequestT = Model::StartAudienceExportJobRequest>
        void StartAudienceExportJobAsync(const StartAudienceExportJobRequestT& request, const StartAudienceExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::StartAudienceExportJob, request, handler, context);
        }
 
        virtual Model::StartAudienceGenerationJobOutcome StartAudienceGenerationJob(const Model::StartAudienceGenerationJobRequest& request) const;
 
        template<typename StartAudienceGenerationJobRequestT = Model::StartAudienceGenerationJobRequest>
        Model::StartAudienceGenerationJobOutcomeCallable StartAudienceGenerationJobCallable(const StartAudienceGenerationJobRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::StartAudienceGenerationJob, request);
        }
 
        template<typename StartAudienceGenerationJobRequestT = Model::StartAudienceGenerationJobRequest>
        void StartAudienceGenerationJobAsync(const StartAudienceGenerationJobRequestT& request, const StartAudienceGenerationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::StartAudienceGenerationJob, 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(&CleanRoomsMLClient::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(&CleanRoomsMLClient::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(&CleanRoomsMLClient::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(&CleanRoomsMLClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateConfiguredAudienceModelOutcome UpdateConfiguredAudienceModel(const Model::UpdateConfiguredAudienceModelRequest& request) const;
 
        template<typename UpdateConfiguredAudienceModelRequestT = Model::UpdateConfiguredAudienceModelRequest>
        Model::UpdateConfiguredAudienceModelOutcomeCallable UpdateConfiguredAudienceModelCallable(const UpdateConfiguredAudienceModelRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::UpdateConfiguredAudienceModel, request);
        }
 
        template<typename UpdateConfiguredAudienceModelRequestT = Model::UpdateConfiguredAudienceModelRequest>
        void UpdateConfiguredAudienceModelAsync(const UpdateConfiguredAudienceModelRequestT& request, const UpdateConfiguredAudienceModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::UpdateConfiguredAudienceModel, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CleanRoomsMLEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CleanRoomsMLClient>;
      void init(const CleanRoomsMLClientConfiguration& clientConfiguration);
 
      CleanRoomsMLClientConfiguration m_clientConfiguration;
      std::shared_ptr<CleanRoomsMLEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CleanRoomsML
} // namespace Aws