NeptunedataClient.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/neptunedata/NeptunedataPaginationBase.h>
#include <aws/neptunedata/NeptunedataServiceClientModel.h>
#include <aws/neptunedata/Neptunedata_EXPORTS.h>
 
namespace Aws {
namespace neptunedata {
class AWS_NEPTUNEDATA_API NeptunedataClient : public Aws::Client::AWSJsonClient,
                                              public Aws::Client::ClientWithAsyncTemplateMethods<NeptunedataClient>,
                                              public NeptunedataPaginationBase<NeptunedataClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef NeptunedataClientConfiguration ClientConfigurationType;
  typedef NeptunedataEndpointProvider EndpointProviderType;
 
  NeptunedataClient(
      const Aws::neptunedata::NeptunedataClientConfiguration& clientConfiguration = Aws::neptunedata::NeptunedataClientConfiguration(),
      std::shared_ptr<NeptunedataEndpointProviderBase> endpointProvider = nullptr);
 
  NeptunedataClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<NeptunedataEndpointProviderBase> endpointProvider = nullptr,
      const Aws::neptunedata::NeptunedataClientConfiguration& clientConfiguration = Aws::neptunedata::NeptunedataClientConfiguration());
 
  NeptunedataClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<NeptunedataEndpointProviderBase> endpointProvider = nullptr,
      const Aws::neptunedata::NeptunedataClientConfiguration& clientConfiguration = Aws::neptunedata::NeptunedataClientConfiguration());
 
  /* Legacy constructors due deprecation */
  NeptunedataClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  NeptunedataClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  NeptunedataClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~NeptunedataClient();
 
  virtual Model::CancelGremlinQueryOutcome CancelGremlinQuery(const Model::CancelGremlinQueryRequest& request) const;
 
  template <typename CancelGremlinQueryRequestT = Model::CancelGremlinQueryRequest>
  Model::CancelGremlinQueryOutcomeCallable CancelGremlinQueryCallable(const CancelGremlinQueryRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::CancelGremlinQuery, request);
  }
 
  template <typename CancelGremlinQueryRequestT = Model::CancelGremlinQueryRequest>
  void CancelGremlinQueryAsync(const CancelGremlinQueryRequestT& request, const CancelGremlinQueryResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::CancelGremlinQuery, request, handler, context);
  }
 
  virtual Model::CancelLoaderJobOutcome CancelLoaderJob(const Model::CancelLoaderJobRequest& request) const;
 
  template <typename CancelLoaderJobRequestT = Model::CancelLoaderJobRequest>
  Model::CancelLoaderJobOutcomeCallable CancelLoaderJobCallable(const CancelLoaderJobRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::CancelLoaderJob, request);
  }
 
  template <typename CancelLoaderJobRequestT = Model::CancelLoaderJobRequest>
  void CancelLoaderJobAsync(const CancelLoaderJobRequestT& request, const CancelLoaderJobResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::CancelLoaderJob, request, handler, context);
  }
 
  virtual Model::CancelMLDataProcessingJobOutcome CancelMLDataProcessingJob(const Model::CancelMLDataProcessingJobRequest& request) const;
 
  template <typename CancelMLDataProcessingJobRequestT = Model::CancelMLDataProcessingJobRequest>
  Model::CancelMLDataProcessingJobOutcomeCallable CancelMLDataProcessingJobCallable(
      const CancelMLDataProcessingJobRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::CancelMLDataProcessingJob, request);
  }
 
  template <typename CancelMLDataProcessingJobRequestT = Model::CancelMLDataProcessingJobRequest>
  void CancelMLDataProcessingJobAsync(const CancelMLDataProcessingJobRequestT& request,
                                      const CancelMLDataProcessingJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::CancelMLDataProcessingJob, request, handler, context);
  }
 
  virtual Model::CancelMLModelTrainingJobOutcome CancelMLModelTrainingJob(const Model::CancelMLModelTrainingJobRequest& request) const;
 
  template <typename CancelMLModelTrainingJobRequestT = Model::CancelMLModelTrainingJobRequest>
  Model::CancelMLModelTrainingJobOutcomeCallable CancelMLModelTrainingJobCallable(const CancelMLModelTrainingJobRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::CancelMLModelTrainingJob, request);
  }
 
  template <typename CancelMLModelTrainingJobRequestT = Model::CancelMLModelTrainingJobRequest>
  void CancelMLModelTrainingJobAsync(const CancelMLModelTrainingJobRequestT& request,
                                     const CancelMLModelTrainingJobResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::CancelMLModelTrainingJob, request, handler, context);
  }
 
  virtual Model::CancelMLModelTransformJobOutcome CancelMLModelTransformJob(const Model::CancelMLModelTransformJobRequest& request) const;
 
  template <typename CancelMLModelTransformJobRequestT = Model::CancelMLModelTransformJobRequest>
  Model::CancelMLModelTransformJobOutcomeCallable CancelMLModelTransformJobCallable(
      const CancelMLModelTransformJobRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::CancelMLModelTransformJob, request);
  }
 
  template <typename CancelMLModelTransformJobRequestT = Model::CancelMLModelTransformJobRequest>
  void CancelMLModelTransformJobAsync(const CancelMLModelTransformJobRequestT& request,
                                      const CancelMLModelTransformJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::CancelMLModelTransformJob, request, handler, context);
  }
 
  virtual Model::CancelOpenCypherQueryOutcome CancelOpenCypherQuery(const Model::CancelOpenCypherQueryRequest& request) const;
 
  template <typename CancelOpenCypherQueryRequestT = Model::CancelOpenCypherQueryRequest>
  Model::CancelOpenCypherQueryOutcomeCallable CancelOpenCypherQueryCallable(const CancelOpenCypherQueryRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::CancelOpenCypherQuery, request);
  }
 
  template <typename CancelOpenCypherQueryRequestT = Model::CancelOpenCypherQueryRequest>
  void CancelOpenCypherQueryAsync(const CancelOpenCypherQueryRequestT& request, const CancelOpenCypherQueryResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::CancelOpenCypherQuery, request, handler, context);
  }
 
  virtual Model::CreateMLEndpointOutcome CreateMLEndpoint(const Model::CreateMLEndpointRequest& request = {}) const;
 
  template <typename CreateMLEndpointRequestT = Model::CreateMLEndpointRequest>
  Model::CreateMLEndpointOutcomeCallable CreateMLEndpointCallable(const CreateMLEndpointRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::CreateMLEndpoint, request);
  }
 
  template <typename CreateMLEndpointRequestT = Model::CreateMLEndpointRequest>
  void CreateMLEndpointAsync(const CreateMLEndpointResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const CreateMLEndpointRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::CreateMLEndpoint, request, handler, context);
  }
 
  virtual Model::DeleteMLEndpointOutcome DeleteMLEndpoint(const Model::DeleteMLEndpointRequest& request) const;
 
  template <typename DeleteMLEndpointRequestT = Model::DeleteMLEndpointRequest>
  Model::DeleteMLEndpointOutcomeCallable DeleteMLEndpointCallable(const DeleteMLEndpointRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::DeleteMLEndpoint, request);
  }
 
  template <typename DeleteMLEndpointRequestT = Model::DeleteMLEndpointRequest>
  void DeleteMLEndpointAsync(const DeleteMLEndpointRequestT& request, const DeleteMLEndpointResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::DeleteMLEndpoint, request, handler, context);
  }
 
  virtual Model::DeletePropertygraphStatisticsOutcome DeletePropertygraphStatistics(
      const Model::DeletePropertygraphStatisticsRequest& request = {}) const;
 
  template <typename DeletePropertygraphStatisticsRequestT = Model::DeletePropertygraphStatisticsRequest>
  Model::DeletePropertygraphStatisticsOutcomeCallable DeletePropertygraphStatisticsCallable(
      const DeletePropertygraphStatisticsRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::DeletePropertygraphStatistics, request);
  }
 
  template <typename DeletePropertygraphStatisticsRequestT = Model::DeletePropertygraphStatisticsRequest>
  void DeletePropertygraphStatisticsAsync(const DeletePropertygraphStatisticsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DeletePropertygraphStatisticsRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::DeletePropertygraphStatistics, request, handler, context);
  }
 
  virtual Model::DeleteSparqlStatisticsOutcome DeleteSparqlStatistics(const Model::DeleteSparqlStatisticsRequest& request = {}) const;
 
  template <typename DeleteSparqlStatisticsRequestT = Model::DeleteSparqlStatisticsRequest>
  Model::DeleteSparqlStatisticsOutcomeCallable DeleteSparqlStatisticsCallable(const DeleteSparqlStatisticsRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::DeleteSparqlStatistics, request);
  }
 
  template <typename DeleteSparqlStatisticsRequestT = Model::DeleteSparqlStatisticsRequest>
  void DeleteSparqlStatisticsAsync(const DeleteSparqlStatisticsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const DeleteSparqlStatisticsRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::DeleteSparqlStatistics, request, handler, context);
  }
 
  virtual Model::ExecuteFastResetOutcome ExecuteFastReset(const Model::ExecuteFastResetRequest& request) const;
 
  template <typename ExecuteFastResetRequestT = Model::ExecuteFastResetRequest>
  Model::ExecuteFastResetOutcomeCallable ExecuteFastResetCallable(const ExecuteFastResetRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::ExecuteFastReset, request);
  }
 
  template <typename ExecuteFastResetRequestT = Model::ExecuteFastResetRequest>
  void ExecuteFastResetAsync(const ExecuteFastResetRequestT& request, const ExecuteFastResetResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::ExecuteFastReset, request, handler, context);
  }
 
  virtual Model::ExecuteGremlinExplainQueryOutcome ExecuteGremlinExplainQuery(
      const Model::ExecuteGremlinExplainQueryRequest& request) const;
 
  template <typename ExecuteGremlinExplainQueryRequestT = Model::ExecuteGremlinExplainQueryRequest>
  Model::ExecuteGremlinExplainQueryOutcomeCallable ExecuteGremlinExplainQueryCallable(
      const ExecuteGremlinExplainQueryRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::ExecuteGremlinExplainQuery, request);
  }
 
  template <typename ExecuteGremlinExplainQueryRequestT = Model::ExecuteGremlinExplainQueryRequest>
  void ExecuteGremlinExplainQueryAsync(const ExecuteGremlinExplainQueryRequestT& request,
                                       const ExecuteGremlinExplainQueryResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::ExecuteGremlinExplainQuery, request, handler, context);
  }
 
  virtual Model::ExecuteGremlinProfileQueryOutcome ExecuteGremlinProfileQuery(
      const Model::ExecuteGremlinProfileQueryRequest& request) const;
 
  template <typename ExecuteGremlinProfileQueryRequestT = Model::ExecuteGremlinProfileQueryRequest>
  Model::ExecuteGremlinProfileQueryOutcomeCallable ExecuteGremlinProfileQueryCallable(
      const ExecuteGremlinProfileQueryRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::ExecuteGremlinProfileQuery, request);
  }
 
  template <typename ExecuteGremlinProfileQueryRequestT = Model::ExecuteGremlinProfileQueryRequest>
  void ExecuteGremlinProfileQueryAsync(const ExecuteGremlinProfileQueryRequestT& request,
                                       const ExecuteGremlinProfileQueryResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::ExecuteGremlinProfileQuery, request, handler, context);
  }
 
  virtual Model::ExecuteGremlinQueryOutcome ExecuteGremlinQuery(const Model::ExecuteGremlinQueryRequest& request) const;
 
  template <typename ExecuteGremlinQueryRequestT = Model::ExecuteGremlinQueryRequest>
  Model::ExecuteGremlinQueryOutcomeCallable ExecuteGremlinQueryCallable(const ExecuteGremlinQueryRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::ExecuteGremlinQuery, request);
  }
 
  template <typename ExecuteGremlinQueryRequestT = Model::ExecuteGremlinQueryRequest>
  void ExecuteGremlinQueryAsync(const ExecuteGremlinQueryRequestT& request, const ExecuteGremlinQueryResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::ExecuteGremlinQuery, request, handler, context);
  }
 
  virtual Model::ExecuteOpenCypherExplainQueryOutcome ExecuteOpenCypherExplainQuery(
      const Model::ExecuteOpenCypherExplainQueryRequest& request) const;
 
  template <typename ExecuteOpenCypherExplainQueryRequestT = Model::ExecuteOpenCypherExplainQueryRequest>
  Model::ExecuteOpenCypherExplainQueryOutcomeCallable ExecuteOpenCypherExplainQueryCallable(
      const ExecuteOpenCypherExplainQueryRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::ExecuteOpenCypherExplainQuery, request);
  }
 
  template <typename ExecuteOpenCypherExplainQueryRequestT = Model::ExecuteOpenCypherExplainQueryRequest>
  void ExecuteOpenCypherExplainQueryAsync(const ExecuteOpenCypherExplainQueryRequestT& request,
                                          const ExecuteOpenCypherExplainQueryResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::ExecuteOpenCypherExplainQuery, request, handler, context);
  }
 
  virtual Model::ExecuteOpenCypherQueryOutcome ExecuteOpenCypherQuery(const Model::ExecuteOpenCypherQueryRequest& request) const;
 
  template <typename ExecuteOpenCypherQueryRequestT = Model::ExecuteOpenCypherQueryRequest>
  Model::ExecuteOpenCypherQueryOutcomeCallable ExecuteOpenCypherQueryCallable(const ExecuteOpenCypherQueryRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::ExecuteOpenCypherQuery, request);
  }
 
  template <typename ExecuteOpenCypherQueryRequestT = Model::ExecuteOpenCypherQueryRequest>
  void ExecuteOpenCypherQueryAsync(const ExecuteOpenCypherQueryRequestT& request,
                                   const ExecuteOpenCypherQueryResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::ExecuteOpenCypherQuery, request, handler, context);
  }
 
  virtual Model::GetEngineStatusOutcome GetEngineStatus(const Model::GetEngineStatusRequest& request = {}) const;
 
  template <typename GetEngineStatusRequestT = Model::GetEngineStatusRequest>
  Model::GetEngineStatusOutcomeCallable GetEngineStatusCallable(const GetEngineStatusRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::GetEngineStatus, request);
  }
 
  template <typename GetEngineStatusRequestT = Model::GetEngineStatusRequest>
  void GetEngineStatusAsync(const GetEngineStatusResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const GetEngineStatusRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::GetEngineStatus, request, handler, context);
  }
 
  virtual Model::GetGremlinQueryStatusOutcome GetGremlinQueryStatus(const Model::GetGremlinQueryStatusRequest& request) const;
 
  template <typename GetGremlinQueryStatusRequestT = Model::GetGremlinQueryStatusRequest>
  Model::GetGremlinQueryStatusOutcomeCallable GetGremlinQueryStatusCallable(const GetGremlinQueryStatusRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::GetGremlinQueryStatus, request);
  }
 
  template <typename GetGremlinQueryStatusRequestT = Model::GetGremlinQueryStatusRequest>
  void GetGremlinQueryStatusAsync(const GetGremlinQueryStatusRequestT& request, const GetGremlinQueryStatusResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::GetGremlinQueryStatus, request, handler, context);
  }
 
  virtual Model::GetLoaderJobStatusOutcome GetLoaderJobStatus(const Model::GetLoaderJobStatusRequest& request) const;
 
  template <typename GetLoaderJobStatusRequestT = Model::GetLoaderJobStatusRequest>
  Model::GetLoaderJobStatusOutcomeCallable GetLoaderJobStatusCallable(const GetLoaderJobStatusRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::GetLoaderJobStatus, request);
  }
 
  template <typename GetLoaderJobStatusRequestT = Model::GetLoaderJobStatusRequest>
  void GetLoaderJobStatusAsync(const GetLoaderJobStatusRequestT& request, const GetLoaderJobStatusResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::GetLoaderJobStatus, request, handler, context);
  }
 
  virtual Model::GetMLDataProcessingJobOutcome GetMLDataProcessingJob(const Model::GetMLDataProcessingJobRequest& request) const;
 
  template <typename GetMLDataProcessingJobRequestT = Model::GetMLDataProcessingJobRequest>
  Model::GetMLDataProcessingJobOutcomeCallable GetMLDataProcessingJobCallable(const GetMLDataProcessingJobRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::GetMLDataProcessingJob, request);
  }
 
  template <typename GetMLDataProcessingJobRequestT = Model::GetMLDataProcessingJobRequest>
  void GetMLDataProcessingJobAsync(const GetMLDataProcessingJobRequestT& request,
                                   const GetMLDataProcessingJobResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::GetMLDataProcessingJob, request, handler, context);
  }
 
  virtual Model::GetMLEndpointOutcome GetMLEndpoint(const Model::GetMLEndpointRequest& request) const;
 
  template <typename GetMLEndpointRequestT = Model::GetMLEndpointRequest>
  Model::GetMLEndpointOutcomeCallable GetMLEndpointCallable(const GetMLEndpointRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::GetMLEndpoint, request);
  }
 
  template <typename GetMLEndpointRequestT = Model::GetMLEndpointRequest>
  void GetMLEndpointAsync(const GetMLEndpointRequestT& request, const GetMLEndpointResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::GetMLEndpoint, request, handler, context);
  }
 
  virtual Model::GetMLModelTrainingJobOutcome GetMLModelTrainingJob(const Model::GetMLModelTrainingJobRequest& request) const;
 
  template <typename GetMLModelTrainingJobRequestT = Model::GetMLModelTrainingJobRequest>
  Model::GetMLModelTrainingJobOutcomeCallable GetMLModelTrainingJobCallable(const GetMLModelTrainingJobRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::GetMLModelTrainingJob, request);
  }
 
  template <typename GetMLModelTrainingJobRequestT = Model::GetMLModelTrainingJobRequest>
  void GetMLModelTrainingJobAsync(const GetMLModelTrainingJobRequestT& request, const GetMLModelTrainingJobResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::GetMLModelTrainingJob, request, handler, context);
  }
 
  virtual Model::GetMLModelTransformJobOutcome GetMLModelTransformJob(const Model::GetMLModelTransformJobRequest& request) const;
 
  template <typename GetMLModelTransformJobRequestT = Model::GetMLModelTransformJobRequest>
  Model::GetMLModelTransformJobOutcomeCallable GetMLModelTransformJobCallable(const GetMLModelTransformJobRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::GetMLModelTransformJob, request);
  }
 
  template <typename GetMLModelTransformJobRequestT = Model::GetMLModelTransformJobRequest>
  void GetMLModelTransformJobAsync(const GetMLModelTransformJobRequestT& request,
                                   const GetMLModelTransformJobResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::GetMLModelTransformJob, request, handler, context);
  }
 
  virtual Model::GetOpenCypherQueryStatusOutcome GetOpenCypherQueryStatus(const Model::GetOpenCypherQueryStatusRequest& request) const;
 
  template <typename GetOpenCypherQueryStatusRequestT = Model::GetOpenCypherQueryStatusRequest>
  Model::GetOpenCypherQueryStatusOutcomeCallable GetOpenCypherQueryStatusCallable(const GetOpenCypherQueryStatusRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::GetOpenCypherQueryStatus, request);
  }
 
  template <typename GetOpenCypherQueryStatusRequestT = Model::GetOpenCypherQueryStatusRequest>
  void GetOpenCypherQueryStatusAsync(const GetOpenCypherQueryStatusRequestT& request,
                                     const GetOpenCypherQueryStatusResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::GetOpenCypherQueryStatus, request, handler, context);
  }
 
  virtual Model::GetPropertygraphStatisticsOutcome GetPropertygraphStatistics(
      const Model::GetPropertygraphStatisticsRequest& request = {}) const;
 
  template <typename GetPropertygraphStatisticsRequestT = Model::GetPropertygraphStatisticsRequest>
  Model::GetPropertygraphStatisticsOutcomeCallable GetPropertygraphStatisticsCallable(
      const GetPropertygraphStatisticsRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::GetPropertygraphStatistics, request);
  }
 
  template <typename GetPropertygraphStatisticsRequestT = Model::GetPropertygraphStatisticsRequest>
  void GetPropertygraphStatisticsAsync(const GetPropertygraphStatisticsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const GetPropertygraphStatisticsRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::GetPropertygraphStatistics, request, handler, context);
  }
 
  virtual Model::GetPropertygraphStreamOutcome GetPropertygraphStream(const Model::GetPropertygraphStreamRequest& request = {}) const;
 
  template <typename GetPropertygraphStreamRequestT = Model::GetPropertygraphStreamRequest>
  Model::GetPropertygraphStreamOutcomeCallable GetPropertygraphStreamCallable(const GetPropertygraphStreamRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::GetPropertygraphStream, request);
  }
 
  template <typename GetPropertygraphStreamRequestT = Model::GetPropertygraphStreamRequest>
  void GetPropertygraphStreamAsync(const GetPropertygraphStreamResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const GetPropertygraphStreamRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::GetPropertygraphStream, request, handler, context);
  }
 
  virtual Model::GetPropertygraphSummaryOutcome GetPropertygraphSummary(const Model::GetPropertygraphSummaryRequest& request = {}) const;
 
  template <typename GetPropertygraphSummaryRequestT = Model::GetPropertygraphSummaryRequest>
  Model::GetPropertygraphSummaryOutcomeCallable GetPropertygraphSummaryCallable(const GetPropertygraphSummaryRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::GetPropertygraphSummary, request);
  }
 
  template <typename GetPropertygraphSummaryRequestT = Model::GetPropertygraphSummaryRequest>
  void GetPropertygraphSummaryAsync(const GetPropertygraphSummaryResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const GetPropertygraphSummaryRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::GetPropertygraphSummary, request, handler, context);
  }
 
  virtual Model::GetRDFGraphSummaryOutcome GetRDFGraphSummary(const Model::GetRDFGraphSummaryRequest& request = {}) const;
 
  template <typename GetRDFGraphSummaryRequestT = Model::GetRDFGraphSummaryRequest>
  Model::GetRDFGraphSummaryOutcomeCallable GetRDFGraphSummaryCallable(const GetRDFGraphSummaryRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::GetRDFGraphSummary, request);
  }
 
  template <typename GetRDFGraphSummaryRequestT = Model::GetRDFGraphSummaryRequest>
  void GetRDFGraphSummaryAsync(const GetRDFGraphSummaryResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const GetRDFGraphSummaryRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::GetRDFGraphSummary, request, handler, context);
  }
 
  virtual Model::GetSparqlStatisticsOutcome GetSparqlStatistics(const Model::GetSparqlStatisticsRequest& request = {}) const;
 
  template <typename GetSparqlStatisticsRequestT = Model::GetSparqlStatisticsRequest>
  Model::GetSparqlStatisticsOutcomeCallable GetSparqlStatisticsCallable(const GetSparqlStatisticsRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::GetSparqlStatistics, request);
  }
 
  template <typename GetSparqlStatisticsRequestT = Model::GetSparqlStatisticsRequest>
  void GetSparqlStatisticsAsync(const GetSparqlStatisticsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const GetSparqlStatisticsRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::GetSparqlStatistics, request, handler, context);
  }
 
  virtual Model::GetSparqlStreamOutcome GetSparqlStream(const Model::GetSparqlStreamRequest& request = {}) const;
 
  template <typename GetSparqlStreamRequestT = Model::GetSparqlStreamRequest>
  Model::GetSparqlStreamOutcomeCallable GetSparqlStreamCallable(const GetSparqlStreamRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::GetSparqlStream, request);
  }
 
  template <typename GetSparqlStreamRequestT = Model::GetSparqlStreamRequest>
  void GetSparqlStreamAsync(const GetSparqlStreamResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const GetSparqlStreamRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::GetSparqlStream, request, handler, context);
  }
 
  virtual Model::ListGremlinQueriesOutcome ListGremlinQueries(const Model::ListGremlinQueriesRequest& request = {}) const;
 
  template <typename ListGremlinQueriesRequestT = Model::ListGremlinQueriesRequest>
  Model::ListGremlinQueriesOutcomeCallable ListGremlinQueriesCallable(const ListGremlinQueriesRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::ListGremlinQueries, request);
  }
 
  template <typename ListGremlinQueriesRequestT = Model::ListGremlinQueriesRequest>
  void ListGremlinQueriesAsync(const ListGremlinQueriesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListGremlinQueriesRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::ListGremlinQueries, request, handler, context);
  }
 
  virtual Model::ListLoaderJobsOutcome ListLoaderJobs(const Model::ListLoaderJobsRequest& request = {}) const;
 
  template <typename ListLoaderJobsRequestT = Model::ListLoaderJobsRequest>
  Model::ListLoaderJobsOutcomeCallable ListLoaderJobsCallable(const ListLoaderJobsRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::ListLoaderJobs, request);
  }
 
  template <typename ListLoaderJobsRequestT = Model::ListLoaderJobsRequest>
  void ListLoaderJobsAsync(const ListLoaderJobsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListLoaderJobsRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::ListLoaderJobs, request, handler, context);
  }
 
  virtual Model::ListMLDataProcessingJobsOutcome ListMLDataProcessingJobs(const Model::ListMLDataProcessingJobsRequest& request = {}) const;
 
  template <typename ListMLDataProcessingJobsRequestT = Model::ListMLDataProcessingJobsRequest>
  Model::ListMLDataProcessingJobsOutcomeCallable ListMLDataProcessingJobsCallable(
      const ListMLDataProcessingJobsRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::ListMLDataProcessingJobs, request);
  }
 
  template <typename ListMLDataProcessingJobsRequestT = Model::ListMLDataProcessingJobsRequest>
  void ListMLDataProcessingJobsAsync(const ListMLDataProcessingJobsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListMLDataProcessingJobsRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::ListMLDataProcessingJobs, request, handler, context);
  }
 
  virtual Model::ListMLEndpointsOutcome ListMLEndpoints(const Model::ListMLEndpointsRequest& request = {}) const;
 
  template <typename ListMLEndpointsRequestT = Model::ListMLEndpointsRequest>
  Model::ListMLEndpointsOutcomeCallable ListMLEndpointsCallable(const ListMLEndpointsRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::ListMLEndpoints, request);
  }
 
  template <typename ListMLEndpointsRequestT = Model::ListMLEndpointsRequest>
  void ListMLEndpointsAsync(const ListMLEndpointsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListMLEndpointsRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::ListMLEndpoints, request, handler, context);
  }
 
  virtual Model::ListMLModelTrainingJobsOutcome ListMLModelTrainingJobs(const Model::ListMLModelTrainingJobsRequest& request = {}) const;
 
  template <typename ListMLModelTrainingJobsRequestT = Model::ListMLModelTrainingJobsRequest>
  Model::ListMLModelTrainingJobsOutcomeCallable ListMLModelTrainingJobsCallable(const ListMLModelTrainingJobsRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::ListMLModelTrainingJobs, request);
  }
 
  template <typename ListMLModelTrainingJobsRequestT = Model::ListMLModelTrainingJobsRequest>
  void ListMLModelTrainingJobsAsync(const ListMLModelTrainingJobsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListMLModelTrainingJobsRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::ListMLModelTrainingJobs, request, handler, context);
  }
 
  virtual Model::ListMLModelTransformJobsOutcome ListMLModelTransformJobs(const Model::ListMLModelTransformJobsRequest& request = {}) const;
 
  template <typename ListMLModelTransformJobsRequestT = Model::ListMLModelTransformJobsRequest>
  Model::ListMLModelTransformJobsOutcomeCallable ListMLModelTransformJobsCallable(
      const ListMLModelTransformJobsRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::ListMLModelTransformJobs, request);
  }
 
  template <typename ListMLModelTransformJobsRequestT = Model::ListMLModelTransformJobsRequest>
  void ListMLModelTransformJobsAsync(const ListMLModelTransformJobsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListMLModelTransformJobsRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::ListMLModelTransformJobs, request, handler, context);
  }
 
  virtual Model::ListOpenCypherQueriesOutcome ListOpenCypherQueries(const Model::ListOpenCypherQueriesRequest& request = {}) const;
 
  template <typename ListOpenCypherQueriesRequestT = Model::ListOpenCypherQueriesRequest>
  Model::ListOpenCypherQueriesOutcomeCallable ListOpenCypherQueriesCallable(const ListOpenCypherQueriesRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::ListOpenCypherQueries, request);
  }
 
  template <typename ListOpenCypherQueriesRequestT = Model::ListOpenCypherQueriesRequest>
  void ListOpenCypherQueriesAsync(const ListOpenCypherQueriesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListOpenCypherQueriesRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::ListOpenCypherQueries, request, handler, context);
  }
 
  virtual Model::ManagePropertygraphStatisticsOutcome ManagePropertygraphStatistics(
      const Model::ManagePropertygraphStatisticsRequest& request = {}) const;
 
  template <typename ManagePropertygraphStatisticsRequestT = Model::ManagePropertygraphStatisticsRequest>
  Model::ManagePropertygraphStatisticsOutcomeCallable ManagePropertygraphStatisticsCallable(
      const ManagePropertygraphStatisticsRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::ManagePropertygraphStatistics, request);
  }
 
  template <typename ManagePropertygraphStatisticsRequestT = Model::ManagePropertygraphStatisticsRequest>
  void ManagePropertygraphStatisticsAsync(const ManagePropertygraphStatisticsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const ManagePropertygraphStatisticsRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::ManagePropertygraphStatistics, request, handler, context);
  }
 
  virtual Model::ManageSparqlStatisticsOutcome ManageSparqlStatistics(const Model::ManageSparqlStatisticsRequest& request = {}) const;
 
  template <typename ManageSparqlStatisticsRequestT = Model::ManageSparqlStatisticsRequest>
  Model::ManageSparqlStatisticsOutcomeCallable ManageSparqlStatisticsCallable(const ManageSparqlStatisticsRequestT& request = {}) const {
    return SubmitCallable(&NeptunedataClient::ManageSparqlStatistics, request);
  }
 
  template <typename ManageSparqlStatisticsRequestT = Model::ManageSparqlStatisticsRequest>
  void ManageSparqlStatisticsAsync(const ManageSparqlStatisticsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ManageSparqlStatisticsRequestT& request = {}) const {
    return SubmitAsync(&NeptunedataClient::ManageSparqlStatistics, request, handler, context);
  }
 
  virtual Model::StartLoaderJobOutcome StartLoaderJob(const Model::StartLoaderJobRequest& request) const;
 
  template <typename StartLoaderJobRequestT = Model::StartLoaderJobRequest>
  Model::StartLoaderJobOutcomeCallable StartLoaderJobCallable(const StartLoaderJobRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::StartLoaderJob, request);
  }
 
  template <typename StartLoaderJobRequestT = Model::StartLoaderJobRequest>
  void StartLoaderJobAsync(const StartLoaderJobRequestT& request, const StartLoaderJobResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::StartLoaderJob, request, handler, context);
  }
 
  virtual Model::StartMLDataProcessingJobOutcome StartMLDataProcessingJob(const Model::StartMLDataProcessingJobRequest& request) const;
 
  template <typename StartMLDataProcessingJobRequestT = Model::StartMLDataProcessingJobRequest>
  Model::StartMLDataProcessingJobOutcomeCallable StartMLDataProcessingJobCallable(const StartMLDataProcessingJobRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::StartMLDataProcessingJob, request);
  }
 
  template <typename StartMLDataProcessingJobRequestT = Model::StartMLDataProcessingJobRequest>
  void StartMLDataProcessingJobAsync(const StartMLDataProcessingJobRequestT& request,
                                     const StartMLDataProcessingJobResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::StartMLDataProcessingJob, request, handler, context);
  }
 
  virtual Model::StartMLModelTrainingJobOutcome StartMLModelTrainingJob(const Model::StartMLModelTrainingJobRequest& request) const;
 
  template <typename StartMLModelTrainingJobRequestT = Model::StartMLModelTrainingJobRequest>
  Model::StartMLModelTrainingJobOutcomeCallable StartMLModelTrainingJobCallable(const StartMLModelTrainingJobRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::StartMLModelTrainingJob, request);
  }
 
  template <typename StartMLModelTrainingJobRequestT = Model::StartMLModelTrainingJobRequest>
  void StartMLModelTrainingJobAsync(const StartMLModelTrainingJobRequestT& request,
                                    const StartMLModelTrainingJobResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::StartMLModelTrainingJob, request, handler, context);
  }
 
  virtual Model::StartMLModelTransformJobOutcome StartMLModelTransformJob(const Model::StartMLModelTransformJobRequest& request) const;
 
  template <typename StartMLModelTransformJobRequestT = Model::StartMLModelTransformJobRequest>
  Model::StartMLModelTransformJobOutcomeCallable StartMLModelTransformJobCallable(const StartMLModelTransformJobRequestT& request) const {
    return SubmitCallable(&NeptunedataClient::StartMLModelTransformJob, request);
  }
 
  template <typename StartMLModelTransformJobRequestT = Model::StartMLModelTransformJobRequest>
  void StartMLModelTransformJobAsync(const StartMLModelTransformJobRequestT& request,
                                     const StartMLModelTransformJobResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptunedataClient::StartMLModelTransformJob, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<NeptunedataEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<NeptunedataClient>;
  void init(const NeptunedataClientConfiguration& clientConfiguration);
 
  NeptunedataClientConfiguration m_clientConfiguration;
  std::shared_ptr<NeptunedataEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace neptunedata
}  // namespace Aws