MachineLearningClient.h

 
#pragma once
#include <aws/machinelearning/MachineLearning_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/machinelearning/MachineLearningServiceClientModel.h>
 
namespace Aws
{
namespace MachineLearning
{
  class AWS_MACHINELEARNING_API MachineLearningClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<MachineLearningClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef MachineLearningClientConfiguration ClientConfigurationType;
      typedef MachineLearningEndpointProvider EndpointProviderType;
 
        MachineLearningClient(const Aws::MachineLearning::MachineLearningClientConfiguration& clientConfiguration = Aws::MachineLearning::MachineLearningClientConfiguration(),
                              std::shared_ptr<MachineLearningEndpointProviderBase> endpointProvider = nullptr);
 
        MachineLearningClient(const Aws::Auth::AWSCredentials& credentials,
                              std::shared_ptr<MachineLearningEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::MachineLearning::MachineLearningClientConfiguration& clientConfiguration = Aws::MachineLearning::MachineLearningClientConfiguration());
 
        MachineLearningClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              std::shared_ptr<MachineLearningEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::MachineLearning::MachineLearningClientConfiguration& clientConfiguration = Aws::MachineLearning::MachineLearningClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        MachineLearningClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        MachineLearningClient(const Aws::Auth::AWSCredentials& credentials,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        MachineLearningClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~MachineLearningClient();
 
        virtual Model::AddTagsOutcome AddTags(const Model::AddTagsRequest& request) const;
 
        template<typename AddTagsRequestT = Model::AddTagsRequest>
        Model::AddTagsOutcomeCallable AddTagsCallable(const AddTagsRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::AddTags, request);
        }
 
        template<typename AddTagsRequestT = Model::AddTagsRequest>
        void AddTagsAsync(const AddTagsRequestT& request, const AddTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::AddTags, request, handler, context);
        }
 
        virtual Model::CreateBatchPredictionOutcome CreateBatchPrediction(const Model::CreateBatchPredictionRequest& request) const;
 
        template<typename CreateBatchPredictionRequestT = Model::CreateBatchPredictionRequest>
        Model::CreateBatchPredictionOutcomeCallable CreateBatchPredictionCallable(const CreateBatchPredictionRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::CreateBatchPrediction, request);
        }
 
        template<typename CreateBatchPredictionRequestT = Model::CreateBatchPredictionRequest>
        void CreateBatchPredictionAsync(const CreateBatchPredictionRequestT& request, const CreateBatchPredictionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::CreateBatchPrediction, request, handler, context);
        }
 
        virtual Model::CreateDataSourceFromRDSOutcome CreateDataSourceFromRDS(const Model::CreateDataSourceFromRDSRequest& request) const;
 
        template<typename CreateDataSourceFromRDSRequestT = Model::CreateDataSourceFromRDSRequest>
        Model::CreateDataSourceFromRDSOutcomeCallable CreateDataSourceFromRDSCallable(const CreateDataSourceFromRDSRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::CreateDataSourceFromRDS, request);
        }
 
        template<typename CreateDataSourceFromRDSRequestT = Model::CreateDataSourceFromRDSRequest>
        void CreateDataSourceFromRDSAsync(const CreateDataSourceFromRDSRequestT& request, const CreateDataSourceFromRDSResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::CreateDataSourceFromRDS, request, handler, context);
        }
 
        virtual Model::CreateDataSourceFromRedshiftOutcome CreateDataSourceFromRedshift(const Model::CreateDataSourceFromRedshiftRequest& request) const;
 
        template<typename CreateDataSourceFromRedshiftRequestT = Model::CreateDataSourceFromRedshiftRequest>
        Model::CreateDataSourceFromRedshiftOutcomeCallable CreateDataSourceFromRedshiftCallable(const CreateDataSourceFromRedshiftRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::CreateDataSourceFromRedshift, request);
        }
 
        template<typename CreateDataSourceFromRedshiftRequestT = Model::CreateDataSourceFromRedshiftRequest>
        void CreateDataSourceFromRedshiftAsync(const CreateDataSourceFromRedshiftRequestT& request, const CreateDataSourceFromRedshiftResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::CreateDataSourceFromRedshift, request, handler, context);
        }
 
        virtual Model::CreateDataSourceFromS3Outcome CreateDataSourceFromS3(const Model::CreateDataSourceFromS3Request& request) const;
 
        template<typename CreateDataSourceFromS3RequestT = Model::CreateDataSourceFromS3Request>
        Model::CreateDataSourceFromS3OutcomeCallable CreateDataSourceFromS3Callable(const CreateDataSourceFromS3RequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::CreateDataSourceFromS3, request);
        }
 
        template<typename CreateDataSourceFromS3RequestT = Model::CreateDataSourceFromS3Request>
        void CreateDataSourceFromS3Async(const CreateDataSourceFromS3RequestT& request, const CreateDataSourceFromS3ResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::CreateDataSourceFromS3, request, handler, context);
        }
 
        virtual Model::CreateEvaluationOutcome CreateEvaluation(const Model::CreateEvaluationRequest& request) const;
 
        template<typename CreateEvaluationRequestT = Model::CreateEvaluationRequest>
        Model::CreateEvaluationOutcomeCallable CreateEvaluationCallable(const CreateEvaluationRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::CreateEvaluation, request);
        }
 
        template<typename CreateEvaluationRequestT = Model::CreateEvaluationRequest>
        void CreateEvaluationAsync(const CreateEvaluationRequestT& request, const CreateEvaluationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::CreateEvaluation, request, handler, context);
        }
 
        virtual Model::CreateMLModelOutcome CreateMLModel(const Model::CreateMLModelRequest& request) const;
 
        template<typename CreateMLModelRequestT = Model::CreateMLModelRequest>
        Model::CreateMLModelOutcomeCallable CreateMLModelCallable(const CreateMLModelRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::CreateMLModel, request);
        }
 
        template<typename CreateMLModelRequestT = Model::CreateMLModelRequest>
        void CreateMLModelAsync(const CreateMLModelRequestT& request, const CreateMLModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::CreateMLModel, request, handler, context);
        }
 
        virtual Model::CreateRealtimeEndpointOutcome CreateRealtimeEndpoint(const Model::CreateRealtimeEndpointRequest& request) const;
 
        template<typename CreateRealtimeEndpointRequestT = Model::CreateRealtimeEndpointRequest>
        Model::CreateRealtimeEndpointOutcomeCallable CreateRealtimeEndpointCallable(const CreateRealtimeEndpointRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::CreateRealtimeEndpoint, request);
        }
 
        template<typename CreateRealtimeEndpointRequestT = Model::CreateRealtimeEndpointRequest>
        void CreateRealtimeEndpointAsync(const CreateRealtimeEndpointRequestT& request, const CreateRealtimeEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::CreateRealtimeEndpoint, request, handler, context);
        }
 
        virtual Model::DeleteBatchPredictionOutcome DeleteBatchPrediction(const Model::DeleteBatchPredictionRequest& request) const;
 
        template<typename DeleteBatchPredictionRequestT = Model::DeleteBatchPredictionRequest>
        Model::DeleteBatchPredictionOutcomeCallable DeleteBatchPredictionCallable(const DeleteBatchPredictionRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::DeleteBatchPrediction, request);
        }
 
        template<typename DeleteBatchPredictionRequestT = Model::DeleteBatchPredictionRequest>
        void DeleteBatchPredictionAsync(const DeleteBatchPredictionRequestT& request, const DeleteBatchPredictionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::DeleteBatchPrediction, request, handler, context);
        }
 
        virtual Model::DeleteDataSourceOutcome DeleteDataSource(const Model::DeleteDataSourceRequest& request) const;
 
        template<typename DeleteDataSourceRequestT = Model::DeleteDataSourceRequest>
        Model::DeleteDataSourceOutcomeCallable DeleteDataSourceCallable(const DeleteDataSourceRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::DeleteDataSource, request);
        }
 
        template<typename DeleteDataSourceRequestT = Model::DeleteDataSourceRequest>
        void DeleteDataSourceAsync(const DeleteDataSourceRequestT& request, const DeleteDataSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::DeleteDataSource, request, handler, context);
        }
 
        virtual Model::DeleteEvaluationOutcome DeleteEvaluation(const Model::DeleteEvaluationRequest& request) const;
 
        template<typename DeleteEvaluationRequestT = Model::DeleteEvaluationRequest>
        Model::DeleteEvaluationOutcomeCallable DeleteEvaluationCallable(const DeleteEvaluationRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::DeleteEvaluation, request);
        }
 
        template<typename DeleteEvaluationRequestT = Model::DeleteEvaluationRequest>
        void DeleteEvaluationAsync(const DeleteEvaluationRequestT& request, const DeleteEvaluationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::DeleteEvaluation, request, handler, context);
        }
 
        virtual Model::DeleteMLModelOutcome DeleteMLModel(const Model::DeleteMLModelRequest& request) const;
 
        template<typename DeleteMLModelRequestT = Model::DeleteMLModelRequest>
        Model::DeleteMLModelOutcomeCallable DeleteMLModelCallable(const DeleteMLModelRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::DeleteMLModel, request);
        }
 
        template<typename DeleteMLModelRequestT = Model::DeleteMLModelRequest>
        void DeleteMLModelAsync(const DeleteMLModelRequestT& request, const DeleteMLModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::DeleteMLModel, request, handler, context);
        }
 
        virtual Model::DeleteRealtimeEndpointOutcome DeleteRealtimeEndpoint(const Model::DeleteRealtimeEndpointRequest& request) const;
 
        template<typename DeleteRealtimeEndpointRequestT = Model::DeleteRealtimeEndpointRequest>
        Model::DeleteRealtimeEndpointOutcomeCallable DeleteRealtimeEndpointCallable(const DeleteRealtimeEndpointRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::DeleteRealtimeEndpoint, request);
        }
 
        template<typename DeleteRealtimeEndpointRequestT = Model::DeleteRealtimeEndpointRequest>
        void DeleteRealtimeEndpointAsync(const DeleteRealtimeEndpointRequestT& request, const DeleteRealtimeEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::DeleteRealtimeEndpoint, request, handler, context);
        }
 
        virtual Model::DeleteTagsOutcome DeleteTags(const Model::DeleteTagsRequest& request) const;
 
        template<typename DeleteTagsRequestT = Model::DeleteTagsRequest>
        Model::DeleteTagsOutcomeCallable DeleteTagsCallable(const DeleteTagsRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::DeleteTags, request);
        }
 
        template<typename DeleteTagsRequestT = Model::DeleteTagsRequest>
        void DeleteTagsAsync(const DeleteTagsRequestT& request, const DeleteTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::DeleteTags, request, handler, context);
        }
 
        virtual Model::DescribeBatchPredictionsOutcome DescribeBatchPredictions(const Model::DescribeBatchPredictionsRequest& request = {}) const;
 
        template<typename DescribeBatchPredictionsRequestT = Model::DescribeBatchPredictionsRequest>
        Model::DescribeBatchPredictionsOutcomeCallable DescribeBatchPredictionsCallable(const DescribeBatchPredictionsRequestT& request = {}) const
        {
            return SubmitCallable(&MachineLearningClient::DescribeBatchPredictions, request);
        }
 
        template<typename DescribeBatchPredictionsRequestT = Model::DescribeBatchPredictionsRequest>
        void DescribeBatchPredictionsAsync(const DescribeBatchPredictionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeBatchPredictionsRequestT& request = {}) const
        {
            return SubmitAsync(&MachineLearningClient::DescribeBatchPredictions, request, handler, context);
        }
 
        virtual Model::DescribeDataSourcesOutcome DescribeDataSources(const Model::DescribeDataSourcesRequest& request = {}) const;
 
        template<typename DescribeDataSourcesRequestT = Model::DescribeDataSourcesRequest>
        Model::DescribeDataSourcesOutcomeCallable DescribeDataSourcesCallable(const DescribeDataSourcesRequestT& request = {}) const
        {
            return SubmitCallable(&MachineLearningClient::DescribeDataSources, request);
        }
 
        template<typename DescribeDataSourcesRequestT = Model::DescribeDataSourcesRequest>
        void DescribeDataSourcesAsync(const DescribeDataSourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDataSourcesRequestT& request = {}) const
        {
            return SubmitAsync(&MachineLearningClient::DescribeDataSources, request, handler, context);
        }
 
        virtual Model::DescribeEvaluationsOutcome DescribeEvaluations(const Model::DescribeEvaluationsRequest& request = {}) const;
 
        template<typename DescribeEvaluationsRequestT = Model::DescribeEvaluationsRequest>
        Model::DescribeEvaluationsOutcomeCallable DescribeEvaluationsCallable(const DescribeEvaluationsRequestT& request = {}) const
        {
            return SubmitCallable(&MachineLearningClient::DescribeEvaluations, request);
        }
 
        template<typename DescribeEvaluationsRequestT = Model::DescribeEvaluationsRequest>
        void DescribeEvaluationsAsync(const DescribeEvaluationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEvaluationsRequestT& request = {}) const
        {
            return SubmitAsync(&MachineLearningClient::DescribeEvaluations, request, handler, context);
        }
 
        virtual Model::DescribeMLModelsOutcome DescribeMLModels(const Model::DescribeMLModelsRequest& request = {}) const;
 
        template<typename DescribeMLModelsRequestT = Model::DescribeMLModelsRequest>
        Model::DescribeMLModelsOutcomeCallable DescribeMLModelsCallable(const DescribeMLModelsRequestT& request = {}) const
        {
            return SubmitCallable(&MachineLearningClient::DescribeMLModels, request);
        }
 
        template<typename DescribeMLModelsRequestT = Model::DescribeMLModelsRequest>
        void DescribeMLModelsAsync(const DescribeMLModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeMLModelsRequestT& request = {}) const
        {
            return SubmitAsync(&MachineLearningClient::DescribeMLModels, request, handler, context);
        }
 
        virtual Model::DescribeTagsOutcome DescribeTags(const Model::DescribeTagsRequest& request) const;
 
        template<typename DescribeTagsRequestT = Model::DescribeTagsRequest>
        Model::DescribeTagsOutcomeCallable DescribeTagsCallable(const DescribeTagsRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::DescribeTags, request);
        }
 
        template<typename DescribeTagsRequestT = Model::DescribeTagsRequest>
        void DescribeTagsAsync(const DescribeTagsRequestT& request, const DescribeTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::DescribeTags, request, handler, context);
        }
 
        virtual Model::GetBatchPredictionOutcome GetBatchPrediction(const Model::GetBatchPredictionRequest& request) const;
 
        template<typename GetBatchPredictionRequestT = Model::GetBatchPredictionRequest>
        Model::GetBatchPredictionOutcomeCallable GetBatchPredictionCallable(const GetBatchPredictionRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::GetBatchPrediction, request);
        }
 
        template<typename GetBatchPredictionRequestT = Model::GetBatchPredictionRequest>
        void GetBatchPredictionAsync(const GetBatchPredictionRequestT& request, const GetBatchPredictionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::GetBatchPrediction, request, handler, context);
        }
 
        virtual Model::GetDataSourceOutcome GetDataSource(const Model::GetDataSourceRequest& request) const;
 
        template<typename GetDataSourceRequestT = Model::GetDataSourceRequest>
        Model::GetDataSourceOutcomeCallable GetDataSourceCallable(const GetDataSourceRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::GetDataSource, request);
        }
 
        template<typename GetDataSourceRequestT = Model::GetDataSourceRequest>
        void GetDataSourceAsync(const GetDataSourceRequestT& request, const GetDataSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::GetDataSource, request, handler, context);
        }
 
        virtual Model::GetEvaluationOutcome GetEvaluation(const Model::GetEvaluationRequest& request) const;
 
        template<typename GetEvaluationRequestT = Model::GetEvaluationRequest>
        Model::GetEvaluationOutcomeCallable GetEvaluationCallable(const GetEvaluationRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::GetEvaluation, request);
        }
 
        template<typename GetEvaluationRequestT = Model::GetEvaluationRequest>
        void GetEvaluationAsync(const GetEvaluationRequestT& request, const GetEvaluationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::GetEvaluation, request, handler, context);
        }
 
        virtual Model::GetMLModelOutcome GetMLModel(const Model::GetMLModelRequest& request) const;
 
        template<typename GetMLModelRequestT = Model::GetMLModelRequest>
        Model::GetMLModelOutcomeCallable GetMLModelCallable(const GetMLModelRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::GetMLModel, request);
        }
 
        template<typename GetMLModelRequestT = Model::GetMLModelRequest>
        void GetMLModelAsync(const GetMLModelRequestT& request, const GetMLModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::GetMLModel, request, handler, context);
        }
 
        virtual Model::PredictOutcome Predict(const Model::PredictRequest& request) const;
 
        template<typename PredictRequestT = Model::PredictRequest>
        Model::PredictOutcomeCallable PredictCallable(const PredictRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::Predict, request);
        }
 
        template<typename PredictRequestT = Model::PredictRequest>
        void PredictAsync(const PredictRequestT& request, const PredictResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::Predict, request, handler, context);
        }
 
        virtual Model::UpdateBatchPredictionOutcome UpdateBatchPrediction(const Model::UpdateBatchPredictionRequest& request) const;
 
        template<typename UpdateBatchPredictionRequestT = Model::UpdateBatchPredictionRequest>
        Model::UpdateBatchPredictionOutcomeCallable UpdateBatchPredictionCallable(const UpdateBatchPredictionRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::UpdateBatchPrediction, request);
        }
 
        template<typename UpdateBatchPredictionRequestT = Model::UpdateBatchPredictionRequest>
        void UpdateBatchPredictionAsync(const UpdateBatchPredictionRequestT& request, const UpdateBatchPredictionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::UpdateBatchPrediction, request, handler, context);
        }
 
        virtual Model::UpdateDataSourceOutcome UpdateDataSource(const Model::UpdateDataSourceRequest& request) const;
 
        template<typename UpdateDataSourceRequestT = Model::UpdateDataSourceRequest>
        Model::UpdateDataSourceOutcomeCallable UpdateDataSourceCallable(const UpdateDataSourceRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::UpdateDataSource, request);
        }
 
        template<typename UpdateDataSourceRequestT = Model::UpdateDataSourceRequest>
        void UpdateDataSourceAsync(const UpdateDataSourceRequestT& request, const UpdateDataSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::UpdateDataSource, request, handler, context);
        }
 
        virtual Model::UpdateEvaluationOutcome UpdateEvaluation(const Model::UpdateEvaluationRequest& request) const;
 
        template<typename UpdateEvaluationRequestT = Model::UpdateEvaluationRequest>
        Model::UpdateEvaluationOutcomeCallable UpdateEvaluationCallable(const UpdateEvaluationRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::UpdateEvaluation, request);
        }
 
        template<typename UpdateEvaluationRequestT = Model::UpdateEvaluationRequest>
        void UpdateEvaluationAsync(const UpdateEvaluationRequestT& request, const UpdateEvaluationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::UpdateEvaluation, request, handler, context);
        }
 
        virtual Model::UpdateMLModelOutcome UpdateMLModel(const Model::UpdateMLModelRequest& request) const;
 
        template<typename UpdateMLModelRequestT = Model::UpdateMLModelRequest>
        Model::UpdateMLModelOutcomeCallable UpdateMLModelCallable(const UpdateMLModelRequestT& request) const
        {
            return SubmitCallable(&MachineLearningClient::UpdateMLModel, request);
        }
 
        template<typename UpdateMLModelRequestT = Model::UpdateMLModelRequest>
        void UpdateMLModelAsync(const UpdateMLModelRequestT& request, const UpdateMLModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MachineLearningClient::UpdateMLModel, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<MachineLearningEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<MachineLearningClient>;
      void init(const MachineLearningClientConfiguration& clientConfiguration);
 
      MachineLearningClientConfiguration m_clientConfiguration;
      std::shared_ptr<MachineLearningEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace MachineLearning
} // namespace Aws