NeptuneGraphClient.h

 
#pragma once
#include <aws/neptune-graph/NeptuneGraph_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/neptune-graph/NeptuneGraphServiceClientModel.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::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::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