NeptunedataClient.h

 
#pragma once
#include <aws/neptunedata/Neptunedata_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/neptunedata/NeptunedataServiceClientModel.h>
 
namespace Aws
{
namespace neptunedata
{
  class AWS_NEPTUNEDATA_API NeptunedataClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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