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::CancelTrainedModelOutcome CancelTrainedModel(const Model::CancelTrainedModelRequest& request) const;
 
        template<typename CancelTrainedModelRequestT = Model::CancelTrainedModelRequest>
        Model::CancelTrainedModelOutcomeCallable CancelTrainedModelCallable(const CancelTrainedModelRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::CancelTrainedModel, request);
        }
 
        template<typename CancelTrainedModelRequestT = Model::CancelTrainedModelRequest>
        void CancelTrainedModelAsync(const CancelTrainedModelRequestT& request, const CancelTrainedModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::CancelTrainedModel, request, handler, context);
        }
 
        virtual Model::CancelTrainedModelInferenceJobOutcome CancelTrainedModelInferenceJob(const Model::CancelTrainedModelInferenceJobRequest& request) const;
 
        template<typename CancelTrainedModelInferenceJobRequestT = Model::CancelTrainedModelInferenceJobRequest>
        Model::CancelTrainedModelInferenceJobOutcomeCallable CancelTrainedModelInferenceJobCallable(const CancelTrainedModelInferenceJobRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::CancelTrainedModelInferenceJob, request);
        }
 
        template<typename CancelTrainedModelInferenceJobRequestT = Model::CancelTrainedModelInferenceJobRequest>
        void CancelTrainedModelInferenceJobAsync(const CancelTrainedModelInferenceJobRequestT& request, const CancelTrainedModelInferenceJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::CancelTrainedModelInferenceJob, request, handler, context);
        }
 
        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::CreateConfiguredModelAlgorithmOutcome CreateConfiguredModelAlgorithm(const Model::CreateConfiguredModelAlgorithmRequest& request) const;
 
        template<typename CreateConfiguredModelAlgorithmRequestT = Model::CreateConfiguredModelAlgorithmRequest>
        Model::CreateConfiguredModelAlgorithmOutcomeCallable CreateConfiguredModelAlgorithmCallable(const CreateConfiguredModelAlgorithmRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::CreateConfiguredModelAlgorithm, request);
        }
 
        template<typename CreateConfiguredModelAlgorithmRequestT = Model::CreateConfiguredModelAlgorithmRequest>
        void CreateConfiguredModelAlgorithmAsync(const CreateConfiguredModelAlgorithmRequestT& request, const CreateConfiguredModelAlgorithmResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::CreateConfiguredModelAlgorithm, request, handler, context);
        }
 
        virtual Model::CreateConfiguredModelAlgorithmAssociationOutcome CreateConfiguredModelAlgorithmAssociation(const Model::CreateConfiguredModelAlgorithmAssociationRequest& request) const;
 
        template<typename CreateConfiguredModelAlgorithmAssociationRequestT = Model::CreateConfiguredModelAlgorithmAssociationRequest>
        Model::CreateConfiguredModelAlgorithmAssociationOutcomeCallable CreateConfiguredModelAlgorithmAssociationCallable(const CreateConfiguredModelAlgorithmAssociationRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::CreateConfiguredModelAlgorithmAssociation, request);
        }
 
        template<typename CreateConfiguredModelAlgorithmAssociationRequestT = Model::CreateConfiguredModelAlgorithmAssociationRequest>
        void CreateConfiguredModelAlgorithmAssociationAsync(const CreateConfiguredModelAlgorithmAssociationRequestT& request, const CreateConfiguredModelAlgorithmAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::CreateConfiguredModelAlgorithmAssociation, request, handler, context);
        }
 
        virtual Model::CreateMLInputChannelOutcome CreateMLInputChannel(const Model::CreateMLInputChannelRequest& request) const;
 
        template<typename CreateMLInputChannelRequestT = Model::CreateMLInputChannelRequest>
        Model::CreateMLInputChannelOutcomeCallable CreateMLInputChannelCallable(const CreateMLInputChannelRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::CreateMLInputChannel, request);
        }
 
        template<typename CreateMLInputChannelRequestT = Model::CreateMLInputChannelRequest>
        void CreateMLInputChannelAsync(const CreateMLInputChannelRequestT& request, const CreateMLInputChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::CreateMLInputChannel, request, handler, context);
        }
 
        virtual Model::CreateTrainedModelOutcome CreateTrainedModel(const Model::CreateTrainedModelRequest& request) const;
 
        template<typename CreateTrainedModelRequestT = Model::CreateTrainedModelRequest>
        Model::CreateTrainedModelOutcomeCallable CreateTrainedModelCallable(const CreateTrainedModelRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::CreateTrainedModel, request);
        }
 
        template<typename CreateTrainedModelRequestT = Model::CreateTrainedModelRequest>
        void CreateTrainedModelAsync(const CreateTrainedModelRequestT& request, const CreateTrainedModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::CreateTrainedModel, 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::DeleteConfiguredModelAlgorithmOutcome DeleteConfiguredModelAlgorithm(const Model::DeleteConfiguredModelAlgorithmRequest& request) const;
 
        template<typename DeleteConfiguredModelAlgorithmRequestT = Model::DeleteConfiguredModelAlgorithmRequest>
        Model::DeleteConfiguredModelAlgorithmOutcomeCallable DeleteConfiguredModelAlgorithmCallable(const DeleteConfiguredModelAlgorithmRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::DeleteConfiguredModelAlgorithm, request);
        }
 
        template<typename DeleteConfiguredModelAlgorithmRequestT = Model::DeleteConfiguredModelAlgorithmRequest>
        void DeleteConfiguredModelAlgorithmAsync(const DeleteConfiguredModelAlgorithmRequestT& request, const DeleteConfiguredModelAlgorithmResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::DeleteConfiguredModelAlgorithm, request, handler, context);
        }
 
        virtual Model::DeleteConfiguredModelAlgorithmAssociationOutcome DeleteConfiguredModelAlgorithmAssociation(const Model::DeleteConfiguredModelAlgorithmAssociationRequest& request) const;
 
        template<typename DeleteConfiguredModelAlgorithmAssociationRequestT = Model::DeleteConfiguredModelAlgorithmAssociationRequest>
        Model::DeleteConfiguredModelAlgorithmAssociationOutcomeCallable DeleteConfiguredModelAlgorithmAssociationCallable(const DeleteConfiguredModelAlgorithmAssociationRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::DeleteConfiguredModelAlgorithmAssociation, request);
        }
 
        template<typename DeleteConfiguredModelAlgorithmAssociationRequestT = Model::DeleteConfiguredModelAlgorithmAssociationRequest>
        void DeleteConfiguredModelAlgorithmAssociationAsync(const DeleteConfiguredModelAlgorithmAssociationRequestT& request, const DeleteConfiguredModelAlgorithmAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::DeleteConfiguredModelAlgorithmAssociation, request, handler, context);
        }
 
        virtual Model::DeleteMLConfigurationOutcome DeleteMLConfiguration(const Model::DeleteMLConfigurationRequest& request) const;
 
        template<typename DeleteMLConfigurationRequestT = Model::DeleteMLConfigurationRequest>
        Model::DeleteMLConfigurationOutcomeCallable DeleteMLConfigurationCallable(const DeleteMLConfigurationRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::DeleteMLConfiguration, request);
        }
 
        template<typename DeleteMLConfigurationRequestT = Model::DeleteMLConfigurationRequest>
        void DeleteMLConfigurationAsync(const DeleteMLConfigurationRequestT& request, const DeleteMLConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::DeleteMLConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteMLInputChannelDataOutcome DeleteMLInputChannelData(const Model::DeleteMLInputChannelDataRequest& request) const;
 
        template<typename DeleteMLInputChannelDataRequestT = Model::DeleteMLInputChannelDataRequest>
        Model::DeleteMLInputChannelDataOutcomeCallable DeleteMLInputChannelDataCallable(const DeleteMLInputChannelDataRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::DeleteMLInputChannelData, request);
        }
 
        template<typename DeleteMLInputChannelDataRequestT = Model::DeleteMLInputChannelDataRequest>
        void DeleteMLInputChannelDataAsync(const DeleteMLInputChannelDataRequestT& request, const DeleteMLInputChannelDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::DeleteMLInputChannelData, request, handler, context);
        }
 
        virtual Model::DeleteTrainedModelOutputOutcome DeleteTrainedModelOutput(const Model::DeleteTrainedModelOutputRequest& request) const;
 
        template<typename DeleteTrainedModelOutputRequestT = Model::DeleteTrainedModelOutputRequest>
        Model::DeleteTrainedModelOutputOutcomeCallable DeleteTrainedModelOutputCallable(const DeleteTrainedModelOutputRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::DeleteTrainedModelOutput, request);
        }
 
        template<typename DeleteTrainedModelOutputRequestT = Model::DeleteTrainedModelOutputRequest>
        void DeleteTrainedModelOutputAsync(const DeleteTrainedModelOutputRequestT& request, const DeleteTrainedModelOutputResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::DeleteTrainedModelOutput, 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::GetCollaborationConfiguredModelAlgorithmAssociationOutcome GetCollaborationConfiguredModelAlgorithmAssociation(const Model::GetCollaborationConfiguredModelAlgorithmAssociationRequest& request) const;
 
        template<typename GetCollaborationConfiguredModelAlgorithmAssociationRequestT = Model::GetCollaborationConfiguredModelAlgorithmAssociationRequest>
        Model::GetCollaborationConfiguredModelAlgorithmAssociationOutcomeCallable GetCollaborationConfiguredModelAlgorithmAssociationCallable(const GetCollaborationConfiguredModelAlgorithmAssociationRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::GetCollaborationConfiguredModelAlgorithmAssociation, request);
        }
 
        template<typename GetCollaborationConfiguredModelAlgorithmAssociationRequestT = Model::GetCollaborationConfiguredModelAlgorithmAssociationRequest>
        void GetCollaborationConfiguredModelAlgorithmAssociationAsync(const GetCollaborationConfiguredModelAlgorithmAssociationRequestT& request, const GetCollaborationConfiguredModelAlgorithmAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::GetCollaborationConfiguredModelAlgorithmAssociation, request, handler, context);
        }
 
        virtual Model::GetCollaborationMLInputChannelOutcome GetCollaborationMLInputChannel(const Model::GetCollaborationMLInputChannelRequest& request) const;
 
        template<typename GetCollaborationMLInputChannelRequestT = Model::GetCollaborationMLInputChannelRequest>
        Model::GetCollaborationMLInputChannelOutcomeCallable GetCollaborationMLInputChannelCallable(const GetCollaborationMLInputChannelRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::GetCollaborationMLInputChannel, request);
        }
 
        template<typename GetCollaborationMLInputChannelRequestT = Model::GetCollaborationMLInputChannelRequest>
        void GetCollaborationMLInputChannelAsync(const GetCollaborationMLInputChannelRequestT& request, const GetCollaborationMLInputChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::GetCollaborationMLInputChannel, request, handler, context);
        }
 
        virtual Model::GetCollaborationTrainedModelOutcome GetCollaborationTrainedModel(const Model::GetCollaborationTrainedModelRequest& request) const;
 
        template<typename GetCollaborationTrainedModelRequestT = Model::GetCollaborationTrainedModelRequest>
        Model::GetCollaborationTrainedModelOutcomeCallable GetCollaborationTrainedModelCallable(const GetCollaborationTrainedModelRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::GetCollaborationTrainedModel, request);
        }
 
        template<typename GetCollaborationTrainedModelRequestT = Model::GetCollaborationTrainedModelRequest>
        void GetCollaborationTrainedModelAsync(const GetCollaborationTrainedModelRequestT& request, const GetCollaborationTrainedModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::GetCollaborationTrainedModel, 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::GetConfiguredModelAlgorithmOutcome GetConfiguredModelAlgorithm(const Model::GetConfiguredModelAlgorithmRequest& request) const;
 
        template<typename GetConfiguredModelAlgorithmRequestT = Model::GetConfiguredModelAlgorithmRequest>
        Model::GetConfiguredModelAlgorithmOutcomeCallable GetConfiguredModelAlgorithmCallable(const GetConfiguredModelAlgorithmRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::GetConfiguredModelAlgorithm, request);
        }
 
        template<typename GetConfiguredModelAlgorithmRequestT = Model::GetConfiguredModelAlgorithmRequest>
        void GetConfiguredModelAlgorithmAsync(const GetConfiguredModelAlgorithmRequestT& request, const GetConfiguredModelAlgorithmResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::GetConfiguredModelAlgorithm, request, handler, context);
        }
 
        virtual Model::GetConfiguredModelAlgorithmAssociationOutcome GetConfiguredModelAlgorithmAssociation(const Model::GetConfiguredModelAlgorithmAssociationRequest& request) const;
 
        template<typename GetConfiguredModelAlgorithmAssociationRequestT = Model::GetConfiguredModelAlgorithmAssociationRequest>
        Model::GetConfiguredModelAlgorithmAssociationOutcomeCallable GetConfiguredModelAlgorithmAssociationCallable(const GetConfiguredModelAlgorithmAssociationRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::GetConfiguredModelAlgorithmAssociation, request);
        }
 
        template<typename GetConfiguredModelAlgorithmAssociationRequestT = Model::GetConfiguredModelAlgorithmAssociationRequest>
        void GetConfiguredModelAlgorithmAssociationAsync(const GetConfiguredModelAlgorithmAssociationRequestT& request, const GetConfiguredModelAlgorithmAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::GetConfiguredModelAlgorithmAssociation, request, handler, context);
        }
 
        virtual Model::GetMLConfigurationOutcome GetMLConfiguration(const Model::GetMLConfigurationRequest& request) const;
 
        template<typename GetMLConfigurationRequestT = Model::GetMLConfigurationRequest>
        Model::GetMLConfigurationOutcomeCallable GetMLConfigurationCallable(const GetMLConfigurationRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::GetMLConfiguration, request);
        }
 
        template<typename GetMLConfigurationRequestT = Model::GetMLConfigurationRequest>
        void GetMLConfigurationAsync(const GetMLConfigurationRequestT& request, const GetMLConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::GetMLConfiguration, request, handler, context);
        }
 
        virtual Model::GetMLInputChannelOutcome GetMLInputChannel(const Model::GetMLInputChannelRequest& request) const;
 
        template<typename GetMLInputChannelRequestT = Model::GetMLInputChannelRequest>
        Model::GetMLInputChannelOutcomeCallable GetMLInputChannelCallable(const GetMLInputChannelRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::GetMLInputChannel, request);
        }
 
        template<typename GetMLInputChannelRequestT = Model::GetMLInputChannelRequest>
        void GetMLInputChannelAsync(const GetMLInputChannelRequestT& request, const GetMLInputChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::GetMLInputChannel, request, handler, context);
        }
 
        virtual Model::GetTrainedModelOutcome GetTrainedModel(const Model::GetTrainedModelRequest& request) const;
 
        template<typename GetTrainedModelRequestT = Model::GetTrainedModelRequest>
        Model::GetTrainedModelOutcomeCallable GetTrainedModelCallable(const GetTrainedModelRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::GetTrainedModel, request);
        }
 
        template<typename GetTrainedModelRequestT = Model::GetTrainedModelRequest>
        void GetTrainedModelAsync(const GetTrainedModelRequestT& request, const GetTrainedModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::GetTrainedModel, request, handler, context);
        }
 
        virtual Model::GetTrainedModelInferenceJobOutcome GetTrainedModelInferenceJob(const Model::GetTrainedModelInferenceJobRequest& request) const;
 
        template<typename GetTrainedModelInferenceJobRequestT = Model::GetTrainedModelInferenceJobRequest>
        Model::GetTrainedModelInferenceJobOutcomeCallable GetTrainedModelInferenceJobCallable(const GetTrainedModelInferenceJobRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::GetTrainedModelInferenceJob, request);
        }
 
        template<typename GetTrainedModelInferenceJobRequestT = Model::GetTrainedModelInferenceJobRequest>
        void GetTrainedModelInferenceJobAsync(const GetTrainedModelInferenceJobRequestT& request, const GetTrainedModelInferenceJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::GetTrainedModelInferenceJob, 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::ListCollaborationConfiguredModelAlgorithmAssociationsOutcome ListCollaborationConfiguredModelAlgorithmAssociations(const Model::ListCollaborationConfiguredModelAlgorithmAssociationsRequest& request) const;
 
        template<typename ListCollaborationConfiguredModelAlgorithmAssociationsRequestT = Model::ListCollaborationConfiguredModelAlgorithmAssociationsRequest>
        Model::ListCollaborationConfiguredModelAlgorithmAssociationsOutcomeCallable ListCollaborationConfiguredModelAlgorithmAssociationsCallable(const ListCollaborationConfiguredModelAlgorithmAssociationsRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::ListCollaborationConfiguredModelAlgorithmAssociations, request);
        }
 
        template<typename ListCollaborationConfiguredModelAlgorithmAssociationsRequestT = Model::ListCollaborationConfiguredModelAlgorithmAssociationsRequest>
        void ListCollaborationConfiguredModelAlgorithmAssociationsAsync(const ListCollaborationConfiguredModelAlgorithmAssociationsRequestT& request, const ListCollaborationConfiguredModelAlgorithmAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::ListCollaborationConfiguredModelAlgorithmAssociations, request, handler, context);
        }
 
        virtual Model::ListCollaborationMLInputChannelsOutcome ListCollaborationMLInputChannels(const Model::ListCollaborationMLInputChannelsRequest& request) const;
 
        template<typename ListCollaborationMLInputChannelsRequestT = Model::ListCollaborationMLInputChannelsRequest>
        Model::ListCollaborationMLInputChannelsOutcomeCallable ListCollaborationMLInputChannelsCallable(const ListCollaborationMLInputChannelsRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::ListCollaborationMLInputChannels, request);
        }
 
        template<typename ListCollaborationMLInputChannelsRequestT = Model::ListCollaborationMLInputChannelsRequest>
        void ListCollaborationMLInputChannelsAsync(const ListCollaborationMLInputChannelsRequestT& request, const ListCollaborationMLInputChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::ListCollaborationMLInputChannels, request, handler, context);
        }
 
        virtual Model::ListCollaborationTrainedModelExportJobsOutcome ListCollaborationTrainedModelExportJobs(const Model::ListCollaborationTrainedModelExportJobsRequest& request) const;
 
        template<typename ListCollaborationTrainedModelExportJobsRequestT = Model::ListCollaborationTrainedModelExportJobsRequest>
        Model::ListCollaborationTrainedModelExportJobsOutcomeCallable ListCollaborationTrainedModelExportJobsCallable(const ListCollaborationTrainedModelExportJobsRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::ListCollaborationTrainedModelExportJobs, request);
        }
 
        template<typename ListCollaborationTrainedModelExportJobsRequestT = Model::ListCollaborationTrainedModelExportJobsRequest>
        void ListCollaborationTrainedModelExportJobsAsync(const ListCollaborationTrainedModelExportJobsRequestT& request, const ListCollaborationTrainedModelExportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::ListCollaborationTrainedModelExportJobs, request, handler, context);
        }
 
        virtual Model::ListCollaborationTrainedModelInferenceJobsOutcome ListCollaborationTrainedModelInferenceJobs(const Model::ListCollaborationTrainedModelInferenceJobsRequest& request) const;
 
        template<typename ListCollaborationTrainedModelInferenceJobsRequestT = Model::ListCollaborationTrainedModelInferenceJobsRequest>
        Model::ListCollaborationTrainedModelInferenceJobsOutcomeCallable ListCollaborationTrainedModelInferenceJobsCallable(const ListCollaborationTrainedModelInferenceJobsRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::ListCollaborationTrainedModelInferenceJobs, request);
        }
 
        template<typename ListCollaborationTrainedModelInferenceJobsRequestT = Model::ListCollaborationTrainedModelInferenceJobsRequest>
        void ListCollaborationTrainedModelInferenceJobsAsync(const ListCollaborationTrainedModelInferenceJobsRequestT& request, const ListCollaborationTrainedModelInferenceJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::ListCollaborationTrainedModelInferenceJobs, request, handler, context);
        }
 
        virtual Model::ListCollaborationTrainedModelsOutcome ListCollaborationTrainedModels(const Model::ListCollaborationTrainedModelsRequest& request) const;
 
        template<typename ListCollaborationTrainedModelsRequestT = Model::ListCollaborationTrainedModelsRequest>
        Model::ListCollaborationTrainedModelsOutcomeCallable ListCollaborationTrainedModelsCallable(const ListCollaborationTrainedModelsRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::ListCollaborationTrainedModels, request);
        }
 
        template<typename ListCollaborationTrainedModelsRequestT = Model::ListCollaborationTrainedModelsRequest>
        void ListCollaborationTrainedModelsAsync(const ListCollaborationTrainedModelsRequestT& request, const ListCollaborationTrainedModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::ListCollaborationTrainedModels, 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::ListConfiguredModelAlgorithmAssociationsOutcome ListConfiguredModelAlgorithmAssociations(const Model::ListConfiguredModelAlgorithmAssociationsRequest& request) const;
 
        template<typename ListConfiguredModelAlgorithmAssociationsRequestT = Model::ListConfiguredModelAlgorithmAssociationsRequest>
        Model::ListConfiguredModelAlgorithmAssociationsOutcomeCallable ListConfiguredModelAlgorithmAssociationsCallable(const ListConfiguredModelAlgorithmAssociationsRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::ListConfiguredModelAlgorithmAssociations, request);
        }
 
        template<typename ListConfiguredModelAlgorithmAssociationsRequestT = Model::ListConfiguredModelAlgorithmAssociationsRequest>
        void ListConfiguredModelAlgorithmAssociationsAsync(const ListConfiguredModelAlgorithmAssociationsRequestT& request, const ListConfiguredModelAlgorithmAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::ListConfiguredModelAlgorithmAssociations, request, handler, context);
        }
 
        virtual Model::ListConfiguredModelAlgorithmsOutcome ListConfiguredModelAlgorithms(const Model::ListConfiguredModelAlgorithmsRequest& request = {}) const;
 
        template<typename ListConfiguredModelAlgorithmsRequestT = Model::ListConfiguredModelAlgorithmsRequest>
        Model::ListConfiguredModelAlgorithmsOutcomeCallable ListConfiguredModelAlgorithmsCallable(const ListConfiguredModelAlgorithmsRequestT& request = {}) const
        {
            return SubmitCallable(&CleanRoomsMLClient::ListConfiguredModelAlgorithms, request);
        }
 
        template<typename ListConfiguredModelAlgorithmsRequestT = Model::ListConfiguredModelAlgorithmsRequest>
        void ListConfiguredModelAlgorithmsAsync(const ListConfiguredModelAlgorithmsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListConfiguredModelAlgorithmsRequestT& request = {}) const
        {
            return SubmitAsync(&CleanRoomsMLClient::ListConfiguredModelAlgorithms, request, handler, context);
        }
 
        virtual Model::ListMLInputChannelsOutcome ListMLInputChannels(const Model::ListMLInputChannelsRequest& request) const;
 
        template<typename ListMLInputChannelsRequestT = Model::ListMLInputChannelsRequest>
        Model::ListMLInputChannelsOutcomeCallable ListMLInputChannelsCallable(const ListMLInputChannelsRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::ListMLInputChannels, request);
        }
 
        template<typename ListMLInputChannelsRequestT = Model::ListMLInputChannelsRequest>
        void ListMLInputChannelsAsync(const ListMLInputChannelsRequestT& request, const ListMLInputChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::ListMLInputChannels, 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::ListTrainedModelInferenceJobsOutcome ListTrainedModelInferenceJobs(const Model::ListTrainedModelInferenceJobsRequest& request) const;
 
        template<typename ListTrainedModelInferenceJobsRequestT = Model::ListTrainedModelInferenceJobsRequest>
        Model::ListTrainedModelInferenceJobsOutcomeCallable ListTrainedModelInferenceJobsCallable(const ListTrainedModelInferenceJobsRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::ListTrainedModelInferenceJobs, request);
        }
 
        template<typename ListTrainedModelInferenceJobsRequestT = Model::ListTrainedModelInferenceJobsRequest>
        void ListTrainedModelInferenceJobsAsync(const ListTrainedModelInferenceJobsRequestT& request, const ListTrainedModelInferenceJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::ListTrainedModelInferenceJobs, request, handler, context);
        }
 
        virtual Model::ListTrainedModelVersionsOutcome ListTrainedModelVersions(const Model::ListTrainedModelVersionsRequest& request) const;
 
        template<typename ListTrainedModelVersionsRequestT = Model::ListTrainedModelVersionsRequest>
        Model::ListTrainedModelVersionsOutcomeCallable ListTrainedModelVersionsCallable(const ListTrainedModelVersionsRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::ListTrainedModelVersions, request);
        }
 
        template<typename ListTrainedModelVersionsRequestT = Model::ListTrainedModelVersionsRequest>
        void ListTrainedModelVersionsAsync(const ListTrainedModelVersionsRequestT& request, const ListTrainedModelVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::ListTrainedModelVersions, request, handler, context);
        }
 
        virtual Model::ListTrainedModelsOutcome ListTrainedModels(const Model::ListTrainedModelsRequest& request) const;
 
        template<typename ListTrainedModelsRequestT = Model::ListTrainedModelsRequest>
        Model::ListTrainedModelsOutcomeCallable ListTrainedModelsCallable(const ListTrainedModelsRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::ListTrainedModels, request);
        }
 
        template<typename ListTrainedModelsRequestT = Model::ListTrainedModelsRequest>
        void ListTrainedModelsAsync(const ListTrainedModelsRequestT& request, const ListTrainedModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::ListTrainedModels, 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::PutMLConfigurationOutcome PutMLConfiguration(const Model::PutMLConfigurationRequest& request) const;
 
        template<typename PutMLConfigurationRequestT = Model::PutMLConfigurationRequest>
        Model::PutMLConfigurationOutcomeCallable PutMLConfigurationCallable(const PutMLConfigurationRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::PutMLConfiguration, request);
        }
 
        template<typename PutMLConfigurationRequestT = Model::PutMLConfigurationRequest>
        void PutMLConfigurationAsync(const PutMLConfigurationRequestT& request, const PutMLConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::PutMLConfiguration, 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::StartTrainedModelExportJobOutcome StartTrainedModelExportJob(const Model::StartTrainedModelExportJobRequest& request) const;
 
        template<typename StartTrainedModelExportJobRequestT = Model::StartTrainedModelExportJobRequest>
        Model::StartTrainedModelExportJobOutcomeCallable StartTrainedModelExportJobCallable(const StartTrainedModelExportJobRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::StartTrainedModelExportJob, request);
        }
 
        template<typename StartTrainedModelExportJobRequestT = Model::StartTrainedModelExportJobRequest>
        void StartTrainedModelExportJobAsync(const StartTrainedModelExportJobRequestT& request, const StartTrainedModelExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::StartTrainedModelExportJob, request, handler, context);
        }
 
        virtual Model::StartTrainedModelInferenceJobOutcome StartTrainedModelInferenceJob(const Model::StartTrainedModelInferenceJobRequest& request) const;
 
        template<typename StartTrainedModelInferenceJobRequestT = Model::StartTrainedModelInferenceJobRequest>
        Model::StartTrainedModelInferenceJobOutcomeCallable StartTrainedModelInferenceJobCallable(const StartTrainedModelInferenceJobRequestT& request) const
        {
            return SubmitCallable(&CleanRoomsMLClient::StartTrainedModelInferenceJob, request);
        }
 
        template<typename StartTrainedModelInferenceJobRequestT = Model::StartTrainedModelInferenceJobRequest>
        void StartTrainedModelInferenceJobAsync(const StartTrainedModelInferenceJobRequestT& request, const StartTrainedModelInferenceJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CleanRoomsMLClient::StartTrainedModelInferenceJob, 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