NeptuneGraphClient.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/neptune-graph/NeptuneGraphServiceClientModel.h>
#include <aws/neptune-graph/NeptuneGraph_EXPORTS.h>
 
namespace Aws {
namespace NeptuneGraph {
class AWS_NEPTUNEGRAPH_API NeptuneGraphClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<NeptuneGraphClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef NeptuneGraphClientConfiguration ClientConfigurationType;
  typedef NeptuneGraphEndpointProvider EndpointProviderType;
 
  NeptuneGraphClient(
      const Aws::NeptuneGraph::NeptuneGraphClientConfiguration& clientConfiguration = Aws::NeptuneGraph::NeptuneGraphClientConfiguration(),
      std::shared_ptr<NeptuneGraphEndpointProviderBase> endpointProvider = nullptr);
 
  NeptuneGraphClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<NeptuneGraphEndpointProviderBase> endpointProvider = nullptr,
      const Aws::NeptuneGraph::NeptuneGraphClientConfiguration& clientConfiguration = Aws::NeptuneGraph::NeptuneGraphClientConfiguration());
 
  NeptuneGraphClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<NeptuneGraphEndpointProviderBase> endpointProvider = nullptr,
      const Aws::NeptuneGraph::NeptuneGraphClientConfiguration& clientConfiguration = Aws::NeptuneGraph::NeptuneGraphClientConfiguration());
 
  /* Legacy constructors due deprecation */
  NeptuneGraphClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  NeptuneGraphClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  NeptuneGraphClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~NeptuneGraphClient();
 
  virtual Model::CancelExportTaskOutcome CancelExportTask(const Model::CancelExportTaskRequest& request) const;
 
  template <typename CancelExportTaskRequestT = Model::CancelExportTaskRequest>
  Model::CancelExportTaskOutcomeCallable CancelExportTaskCallable(const CancelExportTaskRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::CancelExportTask, request);
  }
 
  template <typename CancelExportTaskRequestT = Model::CancelExportTaskRequest>
  void CancelExportTaskAsync(const CancelExportTaskRequestT& request, const CancelExportTaskResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::CancelExportTask, request, handler, context);
  }
 
  virtual Model::CancelImportTaskOutcome CancelImportTask(const Model::CancelImportTaskRequest& request) const;
 
  template <typename CancelImportTaskRequestT = Model::CancelImportTaskRequest>
  Model::CancelImportTaskOutcomeCallable CancelImportTaskCallable(const CancelImportTaskRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::CancelImportTask, request);
  }
 
  template <typename CancelImportTaskRequestT = Model::CancelImportTaskRequest>
  void CancelImportTaskAsync(const CancelImportTaskRequestT& request, const CancelImportTaskResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::CancelImportTask, request, handler, context);
  }
 
  virtual Model::CancelQueryOutcome CancelQuery(const Model::CancelQueryRequest& request) const;
 
  template <typename CancelQueryRequestT = Model::CancelQueryRequest>
  Model::CancelQueryOutcomeCallable CancelQueryCallable(const CancelQueryRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::CancelQuery, request);
  }
 
  template <typename CancelQueryRequestT = Model::CancelQueryRequest>
  void CancelQueryAsync(const CancelQueryRequestT& request, const CancelQueryResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::CancelQuery, request, handler, context);
  }
 
  virtual Model::CreateGraphOutcome CreateGraph(const Model::CreateGraphRequest& request) const;
 
  template <typename CreateGraphRequestT = Model::CreateGraphRequest>
  Model::CreateGraphOutcomeCallable CreateGraphCallable(const CreateGraphRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::CreateGraph, request);
  }
 
  template <typename CreateGraphRequestT = Model::CreateGraphRequest>
  void CreateGraphAsync(const CreateGraphRequestT& request, const CreateGraphResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::CreateGraph, request, handler, context);
  }
 
  virtual Model::CreateGraphSnapshotOutcome CreateGraphSnapshot(const Model::CreateGraphSnapshotRequest& request) const;
 
  template <typename CreateGraphSnapshotRequestT = Model::CreateGraphSnapshotRequest>
  Model::CreateGraphSnapshotOutcomeCallable CreateGraphSnapshotCallable(const CreateGraphSnapshotRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::CreateGraphSnapshot, request);
  }
 
  template <typename CreateGraphSnapshotRequestT = Model::CreateGraphSnapshotRequest>
  void CreateGraphSnapshotAsync(const CreateGraphSnapshotRequestT& request, const CreateGraphSnapshotResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::CreateGraphSnapshot, request, handler, context);
  }
 
  virtual Model::CreateGraphUsingImportTaskOutcome CreateGraphUsingImportTask(
      const Model::CreateGraphUsingImportTaskRequest& request) const;
 
  template <typename CreateGraphUsingImportTaskRequestT = Model::CreateGraphUsingImportTaskRequest>
  Model::CreateGraphUsingImportTaskOutcomeCallable CreateGraphUsingImportTaskCallable(
      const CreateGraphUsingImportTaskRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::CreateGraphUsingImportTask, request);
  }
 
  template <typename CreateGraphUsingImportTaskRequestT = Model::CreateGraphUsingImportTaskRequest>
  void CreateGraphUsingImportTaskAsync(const CreateGraphUsingImportTaskRequestT& request,
                                       const CreateGraphUsingImportTaskResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::CreateGraphUsingImportTask, request, handler, context);
  }
 
  virtual Model::CreatePrivateGraphEndpointOutcome CreatePrivateGraphEndpoint(
      const Model::CreatePrivateGraphEndpointRequest& request) const;
 
  template <typename CreatePrivateGraphEndpointRequestT = Model::CreatePrivateGraphEndpointRequest>
  Model::CreatePrivateGraphEndpointOutcomeCallable CreatePrivateGraphEndpointCallable(
      const CreatePrivateGraphEndpointRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::CreatePrivateGraphEndpoint, request);
  }
 
  template <typename CreatePrivateGraphEndpointRequestT = Model::CreatePrivateGraphEndpointRequest>
  void CreatePrivateGraphEndpointAsync(const CreatePrivateGraphEndpointRequestT& request,
                                       const CreatePrivateGraphEndpointResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::CreatePrivateGraphEndpoint, request, handler, context);
  }
 
  virtual Model::DeleteGraphOutcome DeleteGraph(const Model::DeleteGraphRequest& request) const;
 
  template <typename DeleteGraphRequestT = Model::DeleteGraphRequest>
  Model::DeleteGraphOutcomeCallable DeleteGraphCallable(const DeleteGraphRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::DeleteGraph, request);
  }
 
  template <typename DeleteGraphRequestT = Model::DeleteGraphRequest>
  void DeleteGraphAsync(const DeleteGraphRequestT& request, const DeleteGraphResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::DeleteGraph, request, handler, context);
  }
 
  virtual Model::DeleteGraphSnapshotOutcome DeleteGraphSnapshot(const Model::DeleteGraphSnapshotRequest& request) const;
 
  template <typename DeleteGraphSnapshotRequestT = Model::DeleteGraphSnapshotRequest>
  Model::DeleteGraphSnapshotOutcomeCallable DeleteGraphSnapshotCallable(const DeleteGraphSnapshotRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::DeleteGraphSnapshot, request);
  }
 
  template <typename DeleteGraphSnapshotRequestT = Model::DeleteGraphSnapshotRequest>
  void DeleteGraphSnapshotAsync(const DeleteGraphSnapshotRequestT& request, const DeleteGraphSnapshotResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::DeleteGraphSnapshot, request, handler, context);
  }
 
  virtual Model::DeletePrivateGraphEndpointOutcome DeletePrivateGraphEndpoint(
      const Model::DeletePrivateGraphEndpointRequest& request) const;
 
  template <typename DeletePrivateGraphEndpointRequestT = Model::DeletePrivateGraphEndpointRequest>
  Model::DeletePrivateGraphEndpointOutcomeCallable DeletePrivateGraphEndpointCallable(
      const DeletePrivateGraphEndpointRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::DeletePrivateGraphEndpoint, request);
  }
 
  template <typename DeletePrivateGraphEndpointRequestT = Model::DeletePrivateGraphEndpointRequest>
  void DeletePrivateGraphEndpointAsync(const DeletePrivateGraphEndpointRequestT& request,
                                       const DeletePrivateGraphEndpointResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::DeletePrivateGraphEndpoint, request, handler, context);
  }
 
  virtual Model::ExecuteQueryOutcome ExecuteQuery(const Model::ExecuteQueryRequest& request) const;
 
  template <typename ExecuteQueryRequestT = Model::ExecuteQueryRequest>
  Model::ExecuteQueryOutcomeCallable ExecuteQueryCallable(const ExecuteQueryRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::ExecuteQuery, request);
  }
 
  template <typename ExecuteQueryRequestT = Model::ExecuteQueryRequest>
  void ExecuteQueryAsync(const ExecuteQueryRequestT& request, const ExecuteQueryResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::ExecuteQuery, request, handler, context);
  }
 
  virtual Model::GetExportTaskOutcome GetExportTask(const Model::GetExportTaskRequest& request) const;
 
  template <typename GetExportTaskRequestT = Model::GetExportTaskRequest>
  Model::GetExportTaskOutcomeCallable GetExportTaskCallable(const GetExportTaskRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::GetExportTask, request);
  }
 
  template <typename GetExportTaskRequestT = Model::GetExportTaskRequest>
  void GetExportTaskAsync(const GetExportTaskRequestT& request, const GetExportTaskResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::GetExportTask, request, handler, context);
  }
 
  virtual Model::GetGraphOutcome GetGraph(const Model::GetGraphRequest& request) const;
 
  template <typename GetGraphRequestT = Model::GetGraphRequest>
  Model::GetGraphOutcomeCallable GetGraphCallable(const GetGraphRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::GetGraph, request);
  }
 
  template <typename GetGraphRequestT = Model::GetGraphRequest>
  void GetGraphAsync(const GetGraphRequestT& request, const GetGraphResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::GetGraph, request, handler, context);
  }
 
  virtual Model::GetGraphSnapshotOutcome GetGraphSnapshot(const Model::GetGraphSnapshotRequest& request) const;
 
  template <typename GetGraphSnapshotRequestT = Model::GetGraphSnapshotRequest>
  Model::GetGraphSnapshotOutcomeCallable GetGraphSnapshotCallable(const GetGraphSnapshotRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::GetGraphSnapshot, request);
  }
 
  template <typename GetGraphSnapshotRequestT = Model::GetGraphSnapshotRequest>
  void GetGraphSnapshotAsync(const GetGraphSnapshotRequestT& request, const GetGraphSnapshotResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::GetGraphSnapshot, request, handler, context);
  }
 
  virtual Model::GetGraphSummaryOutcome GetGraphSummary(const Model::GetGraphSummaryRequest& request) const;
 
  template <typename GetGraphSummaryRequestT = Model::GetGraphSummaryRequest>
  Model::GetGraphSummaryOutcomeCallable GetGraphSummaryCallable(const GetGraphSummaryRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::GetGraphSummary, request);
  }
 
  template <typename GetGraphSummaryRequestT = Model::GetGraphSummaryRequest>
  void GetGraphSummaryAsync(const GetGraphSummaryRequestT& request, const GetGraphSummaryResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::GetGraphSummary, request, handler, context);
  }
 
  virtual Model::GetImportTaskOutcome GetImportTask(const Model::GetImportTaskRequest& request) const;
 
  template <typename GetImportTaskRequestT = Model::GetImportTaskRequest>
  Model::GetImportTaskOutcomeCallable GetImportTaskCallable(const GetImportTaskRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::GetImportTask, request);
  }
 
  template <typename GetImportTaskRequestT = Model::GetImportTaskRequest>
  void GetImportTaskAsync(const GetImportTaskRequestT& request, const GetImportTaskResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::GetImportTask, request, handler, context);
  }
 
  virtual Model::GetPrivateGraphEndpointOutcome GetPrivateGraphEndpoint(const Model::GetPrivateGraphEndpointRequest& request) const;
 
  template <typename GetPrivateGraphEndpointRequestT = Model::GetPrivateGraphEndpointRequest>
  Model::GetPrivateGraphEndpointOutcomeCallable GetPrivateGraphEndpointCallable(const GetPrivateGraphEndpointRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::GetPrivateGraphEndpoint, request);
  }
 
  template <typename GetPrivateGraphEndpointRequestT = Model::GetPrivateGraphEndpointRequest>
  void GetPrivateGraphEndpointAsync(const GetPrivateGraphEndpointRequestT& request,
                                    const GetPrivateGraphEndpointResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::GetPrivateGraphEndpoint, request, handler, context);
  }
 
  virtual Model::GetQueryOutcome GetQuery(const Model::GetQueryRequest& request) const;
 
  template <typename GetQueryRequestT = Model::GetQueryRequest>
  Model::GetQueryOutcomeCallable GetQueryCallable(const GetQueryRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::GetQuery, request);
  }
 
  template <typename GetQueryRequestT = Model::GetQueryRequest>
  void GetQueryAsync(const GetQueryRequestT& request, const GetQueryResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::GetQuery, request, handler, context);
  }
 
  virtual Model::ListExportTasksOutcome ListExportTasks(const Model::ListExportTasksRequest& request = {}) const;
 
  template <typename ListExportTasksRequestT = Model::ListExportTasksRequest>
  Model::ListExportTasksOutcomeCallable ListExportTasksCallable(const ListExportTasksRequestT& request = {}) const {
    return SubmitCallable(&NeptuneGraphClient::ListExportTasks, request);
  }
 
  template <typename ListExportTasksRequestT = Model::ListExportTasksRequest>
  void ListExportTasksAsync(const ListExportTasksResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListExportTasksRequestT& request = {}) const {
    return SubmitAsync(&NeptuneGraphClient::ListExportTasks, request, handler, context);
  }
 
  virtual Model::ListGraphSnapshotsOutcome ListGraphSnapshots(const Model::ListGraphSnapshotsRequest& request = {}) const;
 
  template <typename ListGraphSnapshotsRequestT = Model::ListGraphSnapshotsRequest>
  Model::ListGraphSnapshotsOutcomeCallable ListGraphSnapshotsCallable(const ListGraphSnapshotsRequestT& request = {}) const {
    return SubmitCallable(&NeptuneGraphClient::ListGraphSnapshots, request);
  }
 
  template <typename ListGraphSnapshotsRequestT = Model::ListGraphSnapshotsRequest>
  void ListGraphSnapshotsAsync(const ListGraphSnapshotsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListGraphSnapshotsRequestT& request = {}) const {
    return SubmitAsync(&NeptuneGraphClient::ListGraphSnapshots, request, handler, context);
  }
 
  virtual Model::ListGraphsOutcome ListGraphs(const Model::ListGraphsRequest& request = {}) const;
 
  template <typename ListGraphsRequestT = Model::ListGraphsRequest>
  Model::ListGraphsOutcomeCallable ListGraphsCallable(const ListGraphsRequestT& request = {}) const {
    return SubmitCallable(&NeptuneGraphClient::ListGraphs, request);
  }
 
  template <typename ListGraphsRequestT = Model::ListGraphsRequest>
  void ListGraphsAsync(const ListGraphsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListGraphsRequestT& request = {}) const {
    return SubmitAsync(&NeptuneGraphClient::ListGraphs, request, handler, context);
  }
 
  virtual Model::ListImportTasksOutcome ListImportTasks(const Model::ListImportTasksRequest& request = {}) const;
 
  template <typename ListImportTasksRequestT = Model::ListImportTasksRequest>
  Model::ListImportTasksOutcomeCallable ListImportTasksCallable(const ListImportTasksRequestT& request = {}) const {
    return SubmitCallable(&NeptuneGraphClient::ListImportTasks, request);
  }
 
  template <typename ListImportTasksRequestT = Model::ListImportTasksRequest>
  void ListImportTasksAsync(const ListImportTasksResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListImportTasksRequestT& request = {}) const {
    return SubmitAsync(&NeptuneGraphClient::ListImportTasks, request, handler, context);
  }
 
  virtual Model::ListPrivateGraphEndpointsOutcome ListPrivateGraphEndpoints(const Model::ListPrivateGraphEndpointsRequest& request) const;
 
  template <typename ListPrivateGraphEndpointsRequestT = Model::ListPrivateGraphEndpointsRequest>
  Model::ListPrivateGraphEndpointsOutcomeCallable ListPrivateGraphEndpointsCallable(
      const ListPrivateGraphEndpointsRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::ListPrivateGraphEndpoints, request);
  }
 
  template <typename ListPrivateGraphEndpointsRequestT = Model::ListPrivateGraphEndpointsRequest>
  void ListPrivateGraphEndpointsAsync(const ListPrivateGraphEndpointsRequestT& request,
                                      const ListPrivateGraphEndpointsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::ListPrivateGraphEndpoints, request, handler, context);
  }
 
  virtual Model::ListQueriesOutcome ListQueries(const Model::ListQueriesRequest& request) const;
 
  template <typename ListQueriesRequestT = Model::ListQueriesRequest>
  Model::ListQueriesOutcomeCallable ListQueriesCallable(const ListQueriesRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::ListQueries, request);
  }
 
  template <typename ListQueriesRequestT = Model::ListQueriesRequest>
  void ListQueriesAsync(const ListQueriesRequestT& request, const ListQueriesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::ListQueries, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ResetGraphOutcome ResetGraph(const Model::ResetGraphRequest& request) const;
 
  template <typename ResetGraphRequestT = Model::ResetGraphRequest>
  Model::ResetGraphOutcomeCallable ResetGraphCallable(const ResetGraphRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::ResetGraph, request);
  }
 
  template <typename ResetGraphRequestT = Model::ResetGraphRequest>
  void ResetGraphAsync(const ResetGraphRequestT& request, const ResetGraphResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::ResetGraph, request, handler, context);
  }
 
  virtual Model::RestoreGraphFromSnapshotOutcome RestoreGraphFromSnapshot(const Model::RestoreGraphFromSnapshotRequest& request) const;
 
  template <typename RestoreGraphFromSnapshotRequestT = Model::RestoreGraphFromSnapshotRequest>
  Model::RestoreGraphFromSnapshotOutcomeCallable RestoreGraphFromSnapshotCallable(const RestoreGraphFromSnapshotRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::RestoreGraphFromSnapshot, request);
  }
 
  template <typename RestoreGraphFromSnapshotRequestT = Model::RestoreGraphFromSnapshotRequest>
  void RestoreGraphFromSnapshotAsync(const RestoreGraphFromSnapshotRequestT& request,
                                     const RestoreGraphFromSnapshotResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::RestoreGraphFromSnapshot, request, handler, context);
  }
 
  virtual Model::StartExportTaskOutcome StartExportTask(const Model::StartExportTaskRequest& request) const;
 
  template <typename StartExportTaskRequestT = Model::StartExportTaskRequest>
  Model::StartExportTaskOutcomeCallable StartExportTaskCallable(const StartExportTaskRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::StartExportTask, request);
  }
 
  template <typename StartExportTaskRequestT = Model::StartExportTaskRequest>
  void StartExportTaskAsync(const StartExportTaskRequestT& request, const StartExportTaskResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::StartExportTask, request, handler, context);
  }
 
  virtual Model::StartGraphOutcome StartGraph(const Model::StartGraphRequest& request) const;
 
  template <typename StartGraphRequestT = Model::StartGraphRequest>
  Model::StartGraphOutcomeCallable StartGraphCallable(const StartGraphRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::StartGraph, request);
  }
 
  template <typename StartGraphRequestT = Model::StartGraphRequest>
  void StartGraphAsync(const StartGraphRequestT& request, const StartGraphResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::StartGraph, request, handler, context);
  }
 
  virtual Model::StartImportTaskOutcome StartImportTask(const Model::StartImportTaskRequest& request) const;
 
  template <typename StartImportTaskRequestT = Model::StartImportTaskRequest>
  Model::StartImportTaskOutcomeCallable StartImportTaskCallable(const StartImportTaskRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::StartImportTask, request);
  }
 
  template <typename StartImportTaskRequestT = Model::StartImportTaskRequest>
  void StartImportTaskAsync(const StartImportTaskRequestT& request, const StartImportTaskResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::StartImportTask, request, handler, context);
  }
 
  virtual Model::StopGraphOutcome StopGraph(const Model::StopGraphRequest& request) const;
 
  template <typename StopGraphRequestT = Model::StopGraphRequest>
  Model::StopGraphOutcomeCallable StopGraphCallable(const StopGraphRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::StopGraph, request);
  }
 
  template <typename StopGraphRequestT = Model::StopGraphRequest>
  void StopGraphAsync(const StopGraphRequestT& request, const StopGraphResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::StopGraph, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateGraphOutcome UpdateGraph(const Model::UpdateGraphRequest& request) const;
 
  template <typename UpdateGraphRequestT = Model::UpdateGraphRequest>
  Model::UpdateGraphOutcomeCallable UpdateGraphCallable(const UpdateGraphRequestT& request) const {
    return SubmitCallable(&NeptuneGraphClient::UpdateGraph, request);
  }
 
  template <typename UpdateGraphRequestT = Model::UpdateGraphRequest>
  void UpdateGraphAsync(const UpdateGraphRequestT& request, const UpdateGraphResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneGraphClient::UpdateGraph, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<NeptuneGraphEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<NeptuneGraphClient>;
  void init(const NeptuneGraphClientConfiguration& clientConfiguration);
 
  NeptuneGraphClientConfiguration m_clientConfiguration;
  std::shared_ptr<NeptuneGraphEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace NeptuneGraph
}  // namespace Aws