MachineLearningClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/machinelearning/MachineLearningPaginationBase.h>
#include <aws/machinelearning/MachineLearningServiceClientModel.h>
#include <aws/machinelearning/MachineLearningWaiter.h>
#include <aws/machinelearning/MachineLearning_EXPORTS.h>
 
namespace Aws {
namespace MachineLearning {
class AWS_MACHINELEARNING_API MachineLearningClient : public Aws::Client::AWSJsonClient,
                                                      public Aws::Client::ClientWithAsyncTemplateMethods<MachineLearningClient>,
                                                      public MachineLearningPaginationBase<MachineLearningClient>,
                                                      public MachineLearningWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<MachineLearningEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<MachineLearningClient>;
  void init(const MachineLearningClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, MachineLearningError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  MachineLearningClientConfiguration m_clientConfiguration;
  std::shared_ptr<MachineLearningEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace MachineLearning
}  // namespace Aws