NeptuneClient.h

 
#pragma once
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/neptune/NeptunePaginationBase.h>
#include <aws/neptune/NeptuneServiceClientModel.h>
#include <aws/neptune/Neptune_EXPORTS.h>
 
namespace Aws {
namespace Neptune {
class AWS_NEPTUNE_API NeptuneClient : public Aws::Client::AWSXMLClient,
                                      public Aws::Client::ClientWithAsyncTemplateMethods<NeptuneClient>,
                                      public NeptunePaginationBase<NeptuneClient> {
 public:
  typedef Aws::Client::AWSXMLClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef NeptuneClientConfiguration ClientConfigurationType;
  typedef NeptuneEndpointProvider EndpointProviderType;
 
  NeptuneClient(const Aws::Neptune::NeptuneClientConfiguration& clientConfiguration = Aws::Neptune::NeptuneClientConfiguration(),
                std::shared_ptr<NeptuneEndpointProviderBase> endpointProvider = nullptr);
 
  NeptuneClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<NeptuneEndpointProviderBase> endpointProvider = nullptr,
                const Aws::Neptune::NeptuneClientConfiguration& clientConfiguration = Aws::Neptune::NeptuneClientConfiguration());
 
  NeptuneClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                std::shared_ptr<NeptuneEndpointProviderBase> endpointProvider = nullptr,
                const Aws::Neptune::NeptuneClientConfiguration& clientConfiguration = Aws::Neptune::NeptuneClientConfiguration());
 
  /* Legacy constructors due deprecation */
  NeptuneClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  NeptuneClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  NeptuneClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~NeptuneClient();
 
  Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
  virtual Model::AddRoleToDBClusterOutcome AddRoleToDBCluster(const Model::AddRoleToDBClusterRequest& request) const;
 
  template <typename AddRoleToDBClusterRequestT = Model::AddRoleToDBClusterRequest>
  Model::AddRoleToDBClusterOutcomeCallable AddRoleToDBClusterCallable(const AddRoleToDBClusterRequestT& request) const {
    return SubmitCallable(&NeptuneClient::AddRoleToDBCluster, request);
  }
 
  template <typename AddRoleToDBClusterRequestT = Model::AddRoleToDBClusterRequest>
  void AddRoleToDBClusterAsync(const AddRoleToDBClusterRequestT& request, const AddRoleToDBClusterResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::AddRoleToDBCluster, request, handler, context);
  }
 
  virtual Model::AddSourceIdentifierToSubscriptionOutcome AddSourceIdentifierToSubscription(
      const Model::AddSourceIdentifierToSubscriptionRequest& request) const;
 
  template <typename AddSourceIdentifierToSubscriptionRequestT = Model::AddSourceIdentifierToSubscriptionRequest>
  Model::AddSourceIdentifierToSubscriptionOutcomeCallable AddSourceIdentifierToSubscriptionCallable(
      const AddSourceIdentifierToSubscriptionRequestT& request) const {
    return SubmitCallable(&NeptuneClient::AddSourceIdentifierToSubscription, request);
  }
 
  template <typename AddSourceIdentifierToSubscriptionRequestT = Model::AddSourceIdentifierToSubscriptionRequest>
  void AddSourceIdentifierToSubscriptionAsync(const AddSourceIdentifierToSubscriptionRequestT& request,
                                              const AddSourceIdentifierToSubscriptionResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::AddSourceIdentifierToSubscription, request, handler, context);
  }
 
  virtual Model::AddTagsToResourceOutcome AddTagsToResource(const Model::AddTagsToResourceRequest& request) const;
 
  template <typename AddTagsToResourceRequestT = Model::AddTagsToResourceRequest>
  Model::AddTagsToResourceOutcomeCallable AddTagsToResourceCallable(const AddTagsToResourceRequestT& request) const {
    return SubmitCallable(&NeptuneClient::AddTagsToResource, request);
  }
 
  template <typename AddTagsToResourceRequestT = Model::AddTagsToResourceRequest>
  void AddTagsToResourceAsync(const AddTagsToResourceRequestT& request, const AddTagsToResourceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::AddTagsToResource, request, handler, context);
  }
 
  virtual Model::ApplyPendingMaintenanceActionOutcome ApplyPendingMaintenanceAction(
      const Model::ApplyPendingMaintenanceActionRequest& request) const;
 
  template <typename ApplyPendingMaintenanceActionRequestT = Model::ApplyPendingMaintenanceActionRequest>
  Model::ApplyPendingMaintenanceActionOutcomeCallable ApplyPendingMaintenanceActionCallable(
      const ApplyPendingMaintenanceActionRequestT& request) const {
    return SubmitCallable(&NeptuneClient::ApplyPendingMaintenanceAction, request);
  }
 
  template <typename ApplyPendingMaintenanceActionRequestT = Model::ApplyPendingMaintenanceActionRequest>
  void ApplyPendingMaintenanceActionAsync(const ApplyPendingMaintenanceActionRequestT& request,
                                          const ApplyPendingMaintenanceActionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::ApplyPendingMaintenanceAction, request, handler, context);
  }
 
  virtual Model::CopyDBClusterParameterGroupOutcome CopyDBClusterParameterGroup(
      const Model::CopyDBClusterParameterGroupRequest& request) const;
 
  template <typename CopyDBClusterParameterGroupRequestT = Model::CopyDBClusterParameterGroupRequest>
  Model::CopyDBClusterParameterGroupOutcomeCallable CopyDBClusterParameterGroupCallable(
      const CopyDBClusterParameterGroupRequestT& request) const {
    return SubmitCallable(&NeptuneClient::CopyDBClusterParameterGroup, request);
  }
 
  template <typename CopyDBClusterParameterGroupRequestT = Model::CopyDBClusterParameterGroupRequest>
  void CopyDBClusterParameterGroupAsync(const CopyDBClusterParameterGroupRequestT& request,
                                        const CopyDBClusterParameterGroupResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::CopyDBClusterParameterGroup, request, handler, context);
  }
 
  virtual Model::CopyDBClusterSnapshotOutcome CopyDBClusterSnapshot(const Model::CopyDBClusterSnapshotRequest& request) const;
 
  template <typename CopyDBClusterSnapshotRequestT = Model::CopyDBClusterSnapshotRequest>
  Model::CopyDBClusterSnapshotOutcomeCallable CopyDBClusterSnapshotCallable(const CopyDBClusterSnapshotRequestT& request) const {
    return SubmitCallable(&NeptuneClient::CopyDBClusterSnapshot, request);
  }
 
  template <typename CopyDBClusterSnapshotRequestT = Model::CopyDBClusterSnapshotRequest>
  void CopyDBClusterSnapshotAsync(const CopyDBClusterSnapshotRequestT& request, const CopyDBClusterSnapshotResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::CopyDBClusterSnapshot, request, handler, context);
  }
 
  virtual Model::CopyDBParameterGroupOutcome CopyDBParameterGroup(const Model::CopyDBParameterGroupRequest& request) const;
 
  template <typename CopyDBParameterGroupRequestT = Model::CopyDBParameterGroupRequest>
  Model::CopyDBParameterGroupOutcomeCallable CopyDBParameterGroupCallable(const CopyDBParameterGroupRequestT& request) const {
    return SubmitCallable(&NeptuneClient::CopyDBParameterGroup, request);
  }
 
  template <typename CopyDBParameterGroupRequestT = Model::CopyDBParameterGroupRequest>
  void CopyDBParameterGroupAsync(const CopyDBParameterGroupRequestT& request, const CopyDBParameterGroupResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::CopyDBParameterGroup, request, handler, context);
  }
 
  virtual Model::CreateDBClusterOutcome CreateDBCluster(const Model::CreateDBClusterRequest& request) const;
 
  template <typename CreateDBClusterRequestT = Model::CreateDBClusterRequest>
  Model::CreateDBClusterOutcomeCallable CreateDBClusterCallable(const CreateDBClusterRequestT& request) const {
    return SubmitCallable(&NeptuneClient::CreateDBCluster, request);
  }
 
  template <typename CreateDBClusterRequestT = Model::CreateDBClusterRequest>
  void CreateDBClusterAsync(const CreateDBClusterRequestT& request, const CreateDBClusterResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::CreateDBCluster, request, handler, context);
  }
 
  virtual Model::CreateDBClusterEndpointOutcome CreateDBClusterEndpoint(const Model::CreateDBClusterEndpointRequest& request) const;
 
  template <typename CreateDBClusterEndpointRequestT = Model::CreateDBClusterEndpointRequest>
  Model::CreateDBClusterEndpointOutcomeCallable CreateDBClusterEndpointCallable(const CreateDBClusterEndpointRequestT& request) const {
    return SubmitCallable(&NeptuneClient::CreateDBClusterEndpoint, request);
  }
 
  template <typename CreateDBClusterEndpointRequestT = Model::CreateDBClusterEndpointRequest>
  void CreateDBClusterEndpointAsync(const CreateDBClusterEndpointRequestT& request,
                                    const CreateDBClusterEndpointResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::CreateDBClusterEndpoint, request, handler, context);
  }
 
  virtual Model::CreateDBClusterParameterGroupOutcome CreateDBClusterParameterGroup(
      const Model::CreateDBClusterParameterGroupRequest& request) const;
 
  template <typename CreateDBClusterParameterGroupRequestT = Model::CreateDBClusterParameterGroupRequest>
  Model::CreateDBClusterParameterGroupOutcomeCallable CreateDBClusterParameterGroupCallable(
      const CreateDBClusterParameterGroupRequestT& request) const {
    return SubmitCallable(&NeptuneClient::CreateDBClusterParameterGroup, request);
  }
 
  template <typename CreateDBClusterParameterGroupRequestT = Model::CreateDBClusterParameterGroupRequest>
  void CreateDBClusterParameterGroupAsync(const CreateDBClusterParameterGroupRequestT& request,
                                          const CreateDBClusterParameterGroupResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::CreateDBClusterParameterGroup, request, handler, context);
  }
 
  virtual Model::CreateDBClusterSnapshotOutcome CreateDBClusterSnapshot(const Model::CreateDBClusterSnapshotRequest& request) const;
 
  template <typename CreateDBClusterSnapshotRequestT = Model::CreateDBClusterSnapshotRequest>
  Model::CreateDBClusterSnapshotOutcomeCallable CreateDBClusterSnapshotCallable(const CreateDBClusterSnapshotRequestT& request) const {
    return SubmitCallable(&NeptuneClient::CreateDBClusterSnapshot, request);
  }
 
  template <typename CreateDBClusterSnapshotRequestT = Model::CreateDBClusterSnapshotRequest>
  void CreateDBClusterSnapshotAsync(const CreateDBClusterSnapshotRequestT& request,
                                    const CreateDBClusterSnapshotResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::CreateDBClusterSnapshot, request, handler, context);
  }
 
  virtual Model::CreateDBInstanceOutcome CreateDBInstance(const Model::CreateDBInstanceRequest& request) const;
 
  template <typename CreateDBInstanceRequestT = Model::CreateDBInstanceRequest>
  Model::CreateDBInstanceOutcomeCallable CreateDBInstanceCallable(const CreateDBInstanceRequestT& request) const {
    return SubmitCallable(&NeptuneClient::CreateDBInstance, request);
  }
 
  template <typename CreateDBInstanceRequestT = Model::CreateDBInstanceRequest>
  void CreateDBInstanceAsync(const CreateDBInstanceRequestT& request, const CreateDBInstanceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::CreateDBInstance, request, handler, context);
  }
 
  virtual Model::CreateDBParameterGroupOutcome CreateDBParameterGroup(const Model::CreateDBParameterGroupRequest& request) const;
 
  template <typename CreateDBParameterGroupRequestT = Model::CreateDBParameterGroupRequest>
  Model::CreateDBParameterGroupOutcomeCallable CreateDBParameterGroupCallable(const CreateDBParameterGroupRequestT& request) const {
    return SubmitCallable(&NeptuneClient::CreateDBParameterGroup, request);
  }
 
  template <typename CreateDBParameterGroupRequestT = Model::CreateDBParameterGroupRequest>
  void CreateDBParameterGroupAsync(const CreateDBParameterGroupRequestT& request,
                                   const CreateDBParameterGroupResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::CreateDBParameterGroup, request, handler, context);
  }
 
  virtual Model::CreateDBSubnetGroupOutcome CreateDBSubnetGroup(const Model::CreateDBSubnetGroupRequest& request) const;
 
  template <typename CreateDBSubnetGroupRequestT = Model::CreateDBSubnetGroupRequest>
  Model::CreateDBSubnetGroupOutcomeCallable CreateDBSubnetGroupCallable(const CreateDBSubnetGroupRequestT& request) const {
    return SubmitCallable(&NeptuneClient::CreateDBSubnetGroup, request);
  }
 
  template <typename CreateDBSubnetGroupRequestT = Model::CreateDBSubnetGroupRequest>
  void CreateDBSubnetGroupAsync(const CreateDBSubnetGroupRequestT& request, const CreateDBSubnetGroupResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::CreateDBSubnetGroup, request, handler, context);
  }
 
  virtual Model::CreateEventSubscriptionOutcome CreateEventSubscription(const Model::CreateEventSubscriptionRequest& request) const;
 
  template <typename CreateEventSubscriptionRequestT = Model::CreateEventSubscriptionRequest>
  Model::CreateEventSubscriptionOutcomeCallable CreateEventSubscriptionCallable(const CreateEventSubscriptionRequestT& request) const {
    return SubmitCallable(&NeptuneClient::CreateEventSubscription, request);
  }
 
  template <typename CreateEventSubscriptionRequestT = Model::CreateEventSubscriptionRequest>
  void CreateEventSubscriptionAsync(const CreateEventSubscriptionRequestT& request,
                                    const CreateEventSubscriptionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::CreateEventSubscription, request, handler, context);
  }
 
  virtual Model::CreateGlobalClusterOutcome CreateGlobalCluster(const Model::CreateGlobalClusterRequest& request) const;
 
  template <typename CreateGlobalClusterRequestT = Model::CreateGlobalClusterRequest>
  Model::CreateGlobalClusterOutcomeCallable CreateGlobalClusterCallable(const CreateGlobalClusterRequestT& request) const {
    return SubmitCallable(&NeptuneClient::CreateGlobalCluster, request);
  }
 
  template <typename CreateGlobalClusterRequestT = Model::CreateGlobalClusterRequest>
  void CreateGlobalClusterAsync(const CreateGlobalClusterRequestT& request, const CreateGlobalClusterResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::CreateGlobalCluster, request, handler, context);
  }
 
  virtual Model::DeleteDBClusterOutcome DeleteDBCluster(const Model::DeleteDBClusterRequest& request) const;
 
  template <typename DeleteDBClusterRequestT = Model::DeleteDBClusterRequest>
  Model::DeleteDBClusterOutcomeCallable DeleteDBClusterCallable(const DeleteDBClusterRequestT& request) const {
    return SubmitCallable(&NeptuneClient::DeleteDBCluster, request);
  }
 
  template <typename DeleteDBClusterRequestT = Model::DeleteDBClusterRequest>
  void DeleteDBClusterAsync(const DeleteDBClusterRequestT& request, const DeleteDBClusterResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::DeleteDBCluster, request, handler, context);
  }
 
  virtual Model::DeleteDBClusterEndpointOutcome DeleteDBClusterEndpoint(const Model::DeleteDBClusterEndpointRequest& request) const;
 
  template <typename DeleteDBClusterEndpointRequestT = Model::DeleteDBClusterEndpointRequest>
  Model::DeleteDBClusterEndpointOutcomeCallable DeleteDBClusterEndpointCallable(const DeleteDBClusterEndpointRequestT& request) const {
    return SubmitCallable(&NeptuneClient::DeleteDBClusterEndpoint, request);
  }
 
  template <typename DeleteDBClusterEndpointRequestT = Model::DeleteDBClusterEndpointRequest>
  void DeleteDBClusterEndpointAsync(const DeleteDBClusterEndpointRequestT& request,
                                    const DeleteDBClusterEndpointResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::DeleteDBClusterEndpoint, request, handler, context);
  }
 
  virtual Model::DeleteDBClusterParameterGroupOutcome DeleteDBClusterParameterGroup(
      const Model::DeleteDBClusterParameterGroupRequest& request) const;
 
  template <typename DeleteDBClusterParameterGroupRequestT = Model::DeleteDBClusterParameterGroupRequest>
  Model::DeleteDBClusterParameterGroupOutcomeCallable DeleteDBClusterParameterGroupCallable(
      const DeleteDBClusterParameterGroupRequestT& request) const {
    return SubmitCallable(&NeptuneClient::DeleteDBClusterParameterGroup, request);
  }
 
  template <typename DeleteDBClusterParameterGroupRequestT = Model::DeleteDBClusterParameterGroupRequest>
  void DeleteDBClusterParameterGroupAsync(const DeleteDBClusterParameterGroupRequestT& request,
                                          const DeleteDBClusterParameterGroupResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::DeleteDBClusterParameterGroup, request, handler, context);
  }
 
  virtual Model::DeleteDBClusterSnapshotOutcome DeleteDBClusterSnapshot(const Model::DeleteDBClusterSnapshotRequest& request) const;
 
  template <typename DeleteDBClusterSnapshotRequestT = Model::DeleteDBClusterSnapshotRequest>
  Model::DeleteDBClusterSnapshotOutcomeCallable DeleteDBClusterSnapshotCallable(const DeleteDBClusterSnapshotRequestT& request) const {
    return SubmitCallable(&NeptuneClient::DeleteDBClusterSnapshot, request);
  }
 
  template <typename DeleteDBClusterSnapshotRequestT = Model::DeleteDBClusterSnapshotRequest>
  void DeleteDBClusterSnapshotAsync(const DeleteDBClusterSnapshotRequestT& request,
                                    const DeleteDBClusterSnapshotResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::DeleteDBClusterSnapshot, request, handler, context);
  }
 
  virtual Model::DeleteDBInstanceOutcome DeleteDBInstance(const Model::DeleteDBInstanceRequest& request) const;
 
  template <typename DeleteDBInstanceRequestT = Model::DeleteDBInstanceRequest>
  Model::DeleteDBInstanceOutcomeCallable DeleteDBInstanceCallable(const DeleteDBInstanceRequestT& request) const {
    return SubmitCallable(&NeptuneClient::DeleteDBInstance, request);
  }
 
  template <typename DeleteDBInstanceRequestT = Model::DeleteDBInstanceRequest>
  void DeleteDBInstanceAsync(const DeleteDBInstanceRequestT& request, const DeleteDBInstanceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::DeleteDBInstance, request, handler, context);
  }
 
  virtual Model::DeleteDBParameterGroupOutcome DeleteDBParameterGroup(const Model::DeleteDBParameterGroupRequest& request) const;
 
  template <typename DeleteDBParameterGroupRequestT = Model::DeleteDBParameterGroupRequest>
  Model::DeleteDBParameterGroupOutcomeCallable DeleteDBParameterGroupCallable(const DeleteDBParameterGroupRequestT& request) const {
    return SubmitCallable(&NeptuneClient::DeleteDBParameterGroup, request);
  }
 
  template <typename DeleteDBParameterGroupRequestT = Model::DeleteDBParameterGroupRequest>
  void DeleteDBParameterGroupAsync(const DeleteDBParameterGroupRequestT& request,
                                   const DeleteDBParameterGroupResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::DeleteDBParameterGroup, request, handler, context);
  }
 
  virtual Model::DeleteDBSubnetGroupOutcome DeleteDBSubnetGroup(const Model::DeleteDBSubnetGroupRequest& request) const;
 
  template <typename DeleteDBSubnetGroupRequestT = Model::DeleteDBSubnetGroupRequest>
  Model::DeleteDBSubnetGroupOutcomeCallable DeleteDBSubnetGroupCallable(const DeleteDBSubnetGroupRequestT& request) const {
    return SubmitCallable(&NeptuneClient::DeleteDBSubnetGroup, request);
  }
 
  template <typename DeleteDBSubnetGroupRequestT = Model::DeleteDBSubnetGroupRequest>
  void DeleteDBSubnetGroupAsync(const DeleteDBSubnetGroupRequestT& request, const DeleteDBSubnetGroupResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::DeleteDBSubnetGroup, request, handler, context);
  }
 
  virtual Model::DeleteEventSubscriptionOutcome DeleteEventSubscription(const Model::DeleteEventSubscriptionRequest& request) const;
 
  template <typename DeleteEventSubscriptionRequestT = Model::DeleteEventSubscriptionRequest>
  Model::DeleteEventSubscriptionOutcomeCallable DeleteEventSubscriptionCallable(const DeleteEventSubscriptionRequestT& request) const {
    return SubmitCallable(&NeptuneClient::DeleteEventSubscription, request);
  }
 
  template <typename DeleteEventSubscriptionRequestT = Model::DeleteEventSubscriptionRequest>
  void DeleteEventSubscriptionAsync(const DeleteEventSubscriptionRequestT& request,
                                    const DeleteEventSubscriptionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::DeleteEventSubscription, request, handler, context);
  }
 
  virtual Model::DeleteGlobalClusterOutcome DeleteGlobalCluster(const Model::DeleteGlobalClusterRequest& request) const;
 
  template <typename DeleteGlobalClusterRequestT = Model::DeleteGlobalClusterRequest>
  Model::DeleteGlobalClusterOutcomeCallable DeleteGlobalClusterCallable(const DeleteGlobalClusterRequestT& request) const {
    return SubmitCallable(&NeptuneClient::DeleteGlobalCluster, request);
  }
 
  template <typename DeleteGlobalClusterRequestT = Model::DeleteGlobalClusterRequest>
  void DeleteGlobalClusterAsync(const DeleteGlobalClusterRequestT& request, const DeleteGlobalClusterResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::DeleteGlobalCluster, request, handler, context);
  }
 
  virtual Model::DescribeDBClusterEndpointsOutcome DescribeDBClusterEndpoints(
      const Model::DescribeDBClusterEndpointsRequest& request = {}) const;
 
  template <typename DescribeDBClusterEndpointsRequestT = Model::DescribeDBClusterEndpointsRequest>
  Model::DescribeDBClusterEndpointsOutcomeCallable DescribeDBClusterEndpointsCallable(
      const DescribeDBClusterEndpointsRequestT& request = {}) const {
    return SubmitCallable(&NeptuneClient::DescribeDBClusterEndpoints, request);
  }
 
  template <typename DescribeDBClusterEndpointsRequestT = Model::DescribeDBClusterEndpointsRequest>
  void DescribeDBClusterEndpointsAsync(const DescribeDBClusterEndpointsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const DescribeDBClusterEndpointsRequestT& request = {}) const {
    return SubmitAsync(&NeptuneClient::DescribeDBClusterEndpoints, request, handler, context);
  }
 
  virtual Model::DescribeDBClusterParameterGroupsOutcome DescribeDBClusterParameterGroups(
      const Model::DescribeDBClusterParameterGroupsRequest& request = {}) const;
 
  template <typename DescribeDBClusterParameterGroupsRequestT = Model::DescribeDBClusterParameterGroupsRequest>
  Model::DescribeDBClusterParameterGroupsOutcomeCallable DescribeDBClusterParameterGroupsCallable(
      const DescribeDBClusterParameterGroupsRequestT& request = {}) const {
    return SubmitCallable(&NeptuneClient::DescribeDBClusterParameterGroups, request);
  }
 
  template <typename DescribeDBClusterParameterGroupsRequestT = Model::DescribeDBClusterParameterGroupsRequest>
  void DescribeDBClusterParameterGroupsAsync(const DescribeDBClusterParameterGroupsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const DescribeDBClusterParameterGroupsRequestT& request = {}) const {
    return SubmitAsync(&NeptuneClient::DescribeDBClusterParameterGroups, request, handler, context);
  }
 
  virtual Model::DescribeDBClusterParametersOutcome DescribeDBClusterParameters(
      const Model::DescribeDBClusterParametersRequest& request) const;
 
  template <typename DescribeDBClusterParametersRequestT = Model::DescribeDBClusterParametersRequest>
  Model::DescribeDBClusterParametersOutcomeCallable DescribeDBClusterParametersCallable(
      const DescribeDBClusterParametersRequestT& request) const {
    return SubmitCallable(&NeptuneClient::DescribeDBClusterParameters, request);
  }
 
  template <typename DescribeDBClusterParametersRequestT = Model::DescribeDBClusterParametersRequest>
  void DescribeDBClusterParametersAsync(const DescribeDBClusterParametersRequestT& request,
                                        const DescribeDBClusterParametersResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::DescribeDBClusterParameters, request, handler, context);
  }
 
  virtual Model::DescribeDBClusterSnapshotAttributesOutcome DescribeDBClusterSnapshotAttributes(
      const Model::DescribeDBClusterSnapshotAttributesRequest& request) const;
 
  template <typename DescribeDBClusterSnapshotAttributesRequestT = Model::DescribeDBClusterSnapshotAttributesRequest>
  Model::DescribeDBClusterSnapshotAttributesOutcomeCallable DescribeDBClusterSnapshotAttributesCallable(
      const DescribeDBClusterSnapshotAttributesRequestT& request) const {
    return SubmitCallable(&NeptuneClient::DescribeDBClusterSnapshotAttributes, request);
  }
 
  template <typename DescribeDBClusterSnapshotAttributesRequestT = Model::DescribeDBClusterSnapshotAttributesRequest>
  void DescribeDBClusterSnapshotAttributesAsync(const DescribeDBClusterSnapshotAttributesRequestT& request,
                                                const DescribeDBClusterSnapshotAttributesResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::DescribeDBClusterSnapshotAttributes, request, handler, context);
  }
 
  virtual Model::DescribeDBClusterSnapshotsOutcome DescribeDBClusterSnapshots(
      const Model::DescribeDBClusterSnapshotsRequest& request = {}) const;
 
  template <typename DescribeDBClusterSnapshotsRequestT = Model::DescribeDBClusterSnapshotsRequest>
  Model::DescribeDBClusterSnapshotsOutcomeCallable DescribeDBClusterSnapshotsCallable(
      const DescribeDBClusterSnapshotsRequestT& request = {}) const {
    return SubmitCallable(&NeptuneClient::DescribeDBClusterSnapshots, request);
  }
 
  template <typename DescribeDBClusterSnapshotsRequestT = Model::DescribeDBClusterSnapshotsRequest>
  void DescribeDBClusterSnapshotsAsync(const DescribeDBClusterSnapshotsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const DescribeDBClusterSnapshotsRequestT& request = {}) const {
    return SubmitAsync(&NeptuneClient::DescribeDBClusterSnapshots, request, handler, context);
  }
 
  virtual Model::DescribeDBClustersOutcome DescribeDBClusters(const Model::DescribeDBClustersRequest& request = {}) const;
 
  template <typename DescribeDBClustersRequestT = Model::DescribeDBClustersRequest>
  Model::DescribeDBClustersOutcomeCallable DescribeDBClustersCallable(const DescribeDBClustersRequestT& request = {}) const {
    return SubmitCallable(&NeptuneClient::DescribeDBClusters, request);
  }
 
  template <typename DescribeDBClustersRequestT = Model::DescribeDBClustersRequest>
  void DescribeDBClustersAsync(const DescribeDBClustersResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const DescribeDBClustersRequestT& request = {}) const {
    return SubmitAsync(&NeptuneClient::DescribeDBClusters, request, handler, context);
  }
 
  virtual Model::DescribeDBEngineVersionsOutcome DescribeDBEngineVersions(const Model::DescribeDBEngineVersionsRequest& request = {}) const;
 
  template <typename DescribeDBEngineVersionsRequestT = Model::DescribeDBEngineVersionsRequest>
  Model::DescribeDBEngineVersionsOutcomeCallable DescribeDBEngineVersionsCallable(
      const DescribeDBEngineVersionsRequestT& request = {}) const {
    return SubmitCallable(&NeptuneClient::DescribeDBEngineVersions, request);
  }
 
  template <typename DescribeDBEngineVersionsRequestT = Model::DescribeDBEngineVersionsRequest>
  void DescribeDBEngineVersionsAsync(const DescribeDBEngineVersionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeDBEngineVersionsRequestT& request = {}) const {
    return SubmitAsync(&NeptuneClient::DescribeDBEngineVersions, request, handler, context);
  }
 
  virtual Model::DescribeDBInstancesOutcome DescribeDBInstances(const Model::DescribeDBInstancesRequest& request = {}) const;
 
  template <typename DescribeDBInstancesRequestT = Model::DescribeDBInstancesRequest>
  Model::DescribeDBInstancesOutcomeCallable DescribeDBInstancesCallable(const DescribeDBInstancesRequestT& request = {}) const {
    return SubmitCallable(&NeptuneClient::DescribeDBInstances, request);
  }
 
  template <typename DescribeDBInstancesRequestT = Model::DescribeDBInstancesRequest>
  void DescribeDBInstancesAsync(const DescribeDBInstancesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeDBInstancesRequestT& request = {}) const {
    return SubmitAsync(&NeptuneClient::DescribeDBInstances, request, handler, context);
  }
 
  virtual Model::DescribeDBParameterGroupsOutcome DescribeDBParameterGroups(
      const Model::DescribeDBParameterGroupsRequest& request = {}) const;
 
  template <typename DescribeDBParameterGroupsRequestT = Model::DescribeDBParameterGroupsRequest>
  Model::DescribeDBParameterGroupsOutcomeCallable DescribeDBParameterGroupsCallable(
      const DescribeDBParameterGroupsRequestT& request = {}) const {
    return SubmitCallable(&NeptuneClient::DescribeDBParameterGroups, request);
  }
 
  template <typename DescribeDBParameterGroupsRequestT = Model::DescribeDBParameterGroupsRequest>
  void DescribeDBParameterGroupsAsync(const DescribeDBParameterGroupsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeDBParameterGroupsRequestT& request = {}) const {
    return SubmitAsync(&NeptuneClient::DescribeDBParameterGroups, request, handler, context);
  }
 
  virtual Model::DescribeDBParametersOutcome DescribeDBParameters(const Model::DescribeDBParametersRequest& request) const;
 
  template <typename DescribeDBParametersRequestT = Model::DescribeDBParametersRequest>
  Model::DescribeDBParametersOutcomeCallable DescribeDBParametersCallable(const DescribeDBParametersRequestT& request) const {
    return SubmitCallable(&NeptuneClient::DescribeDBParameters, request);
  }
 
  template <typename DescribeDBParametersRequestT = Model::DescribeDBParametersRequest>
  void DescribeDBParametersAsync(const DescribeDBParametersRequestT& request, const DescribeDBParametersResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::DescribeDBParameters, request, handler, context);
  }
 
  virtual Model::DescribeDBSubnetGroupsOutcome DescribeDBSubnetGroups(const Model::DescribeDBSubnetGroupsRequest& request = {}) const;
 
  template <typename DescribeDBSubnetGroupsRequestT = Model::DescribeDBSubnetGroupsRequest>
  Model::DescribeDBSubnetGroupsOutcomeCallable DescribeDBSubnetGroupsCallable(const DescribeDBSubnetGroupsRequestT& request = {}) const {
    return SubmitCallable(&NeptuneClient::DescribeDBSubnetGroups, request);
  }
 
  template <typename DescribeDBSubnetGroupsRequestT = Model::DescribeDBSubnetGroupsRequest>
  void DescribeDBSubnetGroupsAsync(const DescribeDBSubnetGroupsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const DescribeDBSubnetGroupsRequestT& request = {}) const {
    return SubmitAsync(&NeptuneClient::DescribeDBSubnetGroups, request, handler, context);
  }
 
  virtual Model::DescribeEngineDefaultClusterParametersOutcome DescribeEngineDefaultClusterParameters(
      const Model::DescribeEngineDefaultClusterParametersRequest& request) const;
 
  template <typename DescribeEngineDefaultClusterParametersRequestT = Model::DescribeEngineDefaultClusterParametersRequest>
  Model::DescribeEngineDefaultClusterParametersOutcomeCallable DescribeEngineDefaultClusterParametersCallable(
      const DescribeEngineDefaultClusterParametersRequestT& request) const {
    return SubmitCallable(&NeptuneClient::DescribeEngineDefaultClusterParameters, request);
  }
 
  template <typename DescribeEngineDefaultClusterParametersRequestT = Model::DescribeEngineDefaultClusterParametersRequest>
  void DescribeEngineDefaultClusterParametersAsync(const DescribeEngineDefaultClusterParametersRequestT& request,
                                                   const DescribeEngineDefaultClusterParametersResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::DescribeEngineDefaultClusterParameters, request, handler, context);
  }
 
  virtual Model::DescribeEngineDefaultParametersOutcome DescribeEngineDefaultParameters(
      const Model::DescribeEngineDefaultParametersRequest& request) const;
 
  template <typename DescribeEngineDefaultParametersRequestT = Model::DescribeEngineDefaultParametersRequest>
  Model::DescribeEngineDefaultParametersOutcomeCallable DescribeEngineDefaultParametersCallable(
      const DescribeEngineDefaultParametersRequestT& request) const {
    return SubmitCallable(&NeptuneClient::DescribeEngineDefaultParameters, request);
  }
 
  template <typename DescribeEngineDefaultParametersRequestT = Model::DescribeEngineDefaultParametersRequest>
  void DescribeEngineDefaultParametersAsync(const DescribeEngineDefaultParametersRequestT& request,
                                            const DescribeEngineDefaultParametersResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::DescribeEngineDefaultParameters, request, handler, context);
  }
 
  virtual Model::DescribeEventCategoriesOutcome DescribeEventCategories(const Model::DescribeEventCategoriesRequest& request = {}) const;
 
  template <typename DescribeEventCategoriesRequestT = Model::DescribeEventCategoriesRequest>
  Model::DescribeEventCategoriesOutcomeCallable DescribeEventCategoriesCallable(const DescribeEventCategoriesRequestT& request = {}) const {
    return SubmitCallable(&NeptuneClient::DescribeEventCategories, request);
  }
 
  template <typename DescribeEventCategoriesRequestT = Model::DescribeEventCategoriesRequest>
  void DescribeEventCategoriesAsync(const DescribeEventCategoriesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribeEventCategoriesRequestT& request = {}) const {
    return SubmitAsync(&NeptuneClient::DescribeEventCategories, request, handler, context);
  }
 
  virtual Model::DescribeEventSubscriptionsOutcome DescribeEventSubscriptions(
      const Model::DescribeEventSubscriptionsRequest& request = {}) const;
 
  template <typename DescribeEventSubscriptionsRequestT = Model::DescribeEventSubscriptionsRequest>
  Model::DescribeEventSubscriptionsOutcomeCallable DescribeEventSubscriptionsCallable(
      const DescribeEventSubscriptionsRequestT& request = {}) const {
    return SubmitCallable(&NeptuneClient::DescribeEventSubscriptions, request);
  }
 
  template <typename DescribeEventSubscriptionsRequestT = Model::DescribeEventSubscriptionsRequest>
  void DescribeEventSubscriptionsAsync(const DescribeEventSubscriptionsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const DescribeEventSubscriptionsRequestT& request = {}) const {
    return SubmitAsync(&NeptuneClient::DescribeEventSubscriptions, request, handler, context);
  }
 
  virtual Model::DescribeEventsOutcome DescribeEvents(const Model::DescribeEventsRequest& request = {}) const;
 
  template <typename DescribeEventsRequestT = Model::DescribeEventsRequest>
  Model::DescribeEventsOutcomeCallable DescribeEventsCallable(const DescribeEventsRequestT& request = {}) const {
    return SubmitCallable(&NeptuneClient::DescribeEvents, request);
  }
 
  template <typename DescribeEventsRequestT = Model::DescribeEventsRequest>
  void DescribeEventsAsync(const DescribeEventsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const DescribeEventsRequestT& request = {}) const {
    return SubmitAsync(&NeptuneClient::DescribeEvents, request, handler, context);
  }
 
  virtual Model::DescribeGlobalClustersOutcome DescribeGlobalClusters(const Model::DescribeGlobalClustersRequest& request = {}) const;
 
  template <typename DescribeGlobalClustersRequestT = Model::DescribeGlobalClustersRequest>
  Model::DescribeGlobalClustersOutcomeCallable DescribeGlobalClustersCallable(const DescribeGlobalClustersRequestT& request = {}) const {
    return SubmitCallable(&NeptuneClient::DescribeGlobalClusters, request);
  }
 
  template <typename DescribeGlobalClustersRequestT = Model::DescribeGlobalClustersRequest>
  void DescribeGlobalClustersAsync(const DescribeGlobalClustersResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const DescribeGlobalClustersRequestT& request = {}) const {
    return SubmitAsync(&NeptuneClient::DescribeGlobalClusters, request, handler, context);
  }
 
  virtual Model::DescribeOrderableDBInstanceOptionsOutcome DescribeOrderableDBInstanceOptions(
      const Model::DescribeOrderableDBInstanceOptionsRequest& request) const;
 
  template <typename DescribeOrderableDBInstanceOptionsRequestT = Model::DescribeOrderableDBInstanceOptionsRequest>
  Model::DescribeOrderableDBInstanceOptionsOutcomeCallable DescribeOrderableDBInstanceOptionsCallable(
      const DescribeOrderableDBInstanceOptionsRequestT& request) const {
    return SubmitCallable(&NeptuneClient::DescribeOrderableDBInstanceOptions, request);
  }
 
  template <typename DescribeOrderableDBInstanceOptionsRequestT = Model::DescribeOrderableDBInstanceOptionsRequest>
  void DescribeOrderableDBInstanceOptionsAsync(const DescribeOrderableDBInstanceOptionsRequestT& request,
                                               const DescribeOrderableDBInstanceOptionsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::DescribeOrderableDBInstanceOptions, request, handler, context);
  }
 
  virtual Model::DescribePendingMaintenanceActionsOutcome DescribePendingMaintenanceActions(
      const Model::DescribePendingMaintenanceActionsRequest& request = {}) const;
 
  template <typename DescribePendingMaintenanceActionsRequestT = Model::DescribePendingMaintenanceActionsRequest>
  Model::DescribePendingMaintenanceActionsOutcomeCallable DescribePendingMaintenanceActionsCallable(
      const DescribePendingMaintenanceActionsRequestT& request = {}) const {
    return SubmitCallable(&NeptuneClient::DescribePendingMaintenanceActions, request);
  }
 
  template <typename DescribePendingMaintenanceActionsRequestT = Model::DescribePendingMaintenanceActionsRequest>
  void DescribePendingMaintenanceActionsAsync(const DescribePendingMaintenanceActionsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const DescribePendingMaintenanceActionsRequestT& request = {}) const {
    return SubmitAsync(&NeptuneClient::DescribePendingMaintenanceActions, request, handler, context);
  }
 
  virtual Model::DescribeValidDBInstanceModificationsOutcome DescribeValidDBInstanceModifications(
      const Model::DescribeValidDBInstanceModificationsRequest& request) const;
 
  template <typename DescribeValidDBInstanceModificationsRequestT = Model::DescribeValidDBInstanceModificationsRequest>
  Model::DescribeValidDBInstanceModificationsOutcomeCallable DescribeValidDBInstanceModificationsCallable(
      const DescribeValidDBInstanceModificationsRequestT& request) const {
    return SubmitCallable(&NeptuneClient::DescribeValidDBInstanceModifications, request);
  }
 
  template <typename DescribeValidDBInstanceModificationsRequestT = Model::DescribeValidDBInstanceModificationsRequest>
  void DescribeValidDBInstanceModificationsAsync(const DescribeValidDBInstanceModificationsRequestT& request,
                                                 const DescribeValidDBInstanceModificationsResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::DescribeValidDBInstanceModifications, request, handler, context);
  }
 
  virtual Model::FailoverDBClusterOutcome FailoverDBCluster(const Model::FailoverDBClusterRequest& request = {}) const;
 
  template <typename FailoverDBClusterRequestT = Model::FailoverDBClusterRequest>
  Model::FailoverDBClusterOutcomeCallable FailoverDBClusterCallable(const FailoverDBClusterRequestT& request = {}) const {
    return SubmitCallable(&NeptuneClient::FailoverDBCluster, request);
  }
 
  template <typename FailoverDBClusterRequestT = Model::FailoverDBClusterRequest>
  void FailoverDBClusterAsync(const FailoverDBClusterResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const FailoverDBClusterRequestT& request = {}) const {
    return SubmitAsync(&NeptuneClient::FailoverDBCluster, request, handler, context);
  }
 
  virtual Model::FailoverGlobalClusterOutcome FailoverGlobalCluster(const Model::FailoverGlobalClusterRequest& request) const;
 
  template <typename FailoverGlobalClusterRequestT = Model::FailoverGlobalClusterRequest>
  Model::FailoverGlobalClusterOutcomeCallable FailoverGlobalClusterCallable(const FailoverGlobalClusterRequestT& request) const {
    return SubmitCallable(&NeptuneClient::FailoverGlobalCluster, request);
  }
 
  template <typename FailoverGlobalClusterRequestT = Model::FailoverGlobalClusterRequest>
  void FailoverGlobalClusterAsync(const FailoverGlobalClusterRequestT& request, const FailoverGlobalClusterResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::FailoverGlobalCluster, 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(&NeptuneClient::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(&NeptuneClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ModifyDBClusterOutcome ModifyDBCluster(const Model::ModifyDBClusterRequest& request) const;
 
  template <typename ModifyDBClusterRequestT = Model::ModifyDBClusterRequest>
  Model::ModifyDBClusterOutcomeCallable ModifyDBClusterCallable(const ModifyDBClusterRequestT& request) const {
    return SubmitCallable(&NeptuneClient::ModifyDBCluster, request);
  }
 
  template <typename ModifyDBClusterRequestT = Model::ModifyDBClusterRequest>
  void ModifyDBClusterAsync(const ModifyDBClusterRequestT& request, const ModifyDBClusterResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::ModifyDBCluster, request, handler, context);
  }
 
  virtual Model::ModifyDBClusterEndpointOutcome ModifyDBClusterEndpoint(const Model::ModifyDBClusterEndpointRequest& request) const;
 
  template <typename ModifyDBClusterEndpointRequestT = Model::ModifyDBClusterEndpointRequest>
  Model::ModifyDBClusterEndpointOutcomeCallable ModifyDBClusterEndpointCallable(const ModifyDBClusterEndpointRequestT& request) const {
    return SubmitCallable(&NeptuneClient::ModifyDBClusterEndpoint, request);
  }
 
  template <typename ModifyDBClusterEndpointRequestT = Model::ModifyDBClusterEndpointRequest>
  void ModifyDBClusterEndpointAsync(const ModifyDBClusterEndpointRequestT& request,
                                    const ModifyDBClusterEndpointResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::ModifyDBClusterEndpoint, request, handler, context);
  }
 
  virtual Model::ModifyDBClusterParameterGroupOutcome ModifyDBClusterParameterGroup(
      const Model::ModifyDBClusterParameterGroupRequest& request) const;
 
  template <typename ModifyDBClusterParameterGroupRequestT = Model::ModifyDBClusterParameterGroupRequest>
  Model::ModifyDBClusterParameterGroupOutcomeCallable ModifyDBClusterParameterGroupCallable(
      const ModifyDBClusterParameterGroupRequestT& request) const {
    return SubmitCallable(&NeptuneClient::ModifyDBClusterParameterGroup, request);
  }
 
  template <typename ModifyDBClusterParameterGroupRequestT = Model::ModifyDBClusterParameterGroupRequest>
  void ModifyDBClusterParameterGroupAsync(const ModifyDBClusterParameterGroupRequestT& request,
                                          const ModifyDBClusterParameterGroupResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::ModifyDBClusterParameterGroup, request, handler, context);
  }
 
  virtual Model::ModifyDBClusterSnapshotAttributeOutcome ModifyDBClusterSnapshotAttribute(
      const Model::ModifyDBClusterSnapshotAttributeRequest& request) const;
 
  template <typename ModifyDBClusterSnapshotAttributeRequestT = Model::ModifyDBClusterSnapshotAttributeRequest>
  Model::ModifyDBClusterSnapshotAttributeOutcomeCallable ModifyDBClusterSnapshotAttributeCallable(
      const ModifyDBClusterSnapshotAttributeRequestT& request) const {
    return SubmitCallable(&NeptuneClient::ModifyDBClusterSnapshotAttribute, request);
  }
 
  template <typename ModifyDBClusterSnapshotAttributeRequestT = Model::ModifyDBClusterSnapshotAttributeRequest>
  void ModifyDBClusterSnapshotAttributeAsync(const ModifyDBClusterSnapshotAttributeRequestT& request,
                                             const ModifyDBClusterSnapshotAttributeResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::ModifyDBClusterSnapshotAttribute, request, handler, context);
  }
 
  virtual Model::ModifyDBInstanceOutcome ModifyDBInstance(const Model::ModifyDBInstanceRequest& request) const;
 
  template <typename ModifyDBInstanceRequestT = Model::ModifyDBInstanceRequest>
  Model::ModifyDBInstanceOutcomeCallable ModifyDBInstanceCallable(const ModifyDBInstanceRequestT& request) const {
    return SubmitCallable(&NeptuneClient::ModifyDBInstance, request);
  }
 
  template <typename ModifyDBInstanceRequestT = Model::ModifyDBInstanceRequest>
  void ModifyDBInstanceAsync(const ModifyDBInstanceRequestT& request, const ModifyDBInstanceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::ModifyDBInstance, request, handler, context);
  }
 
  virtual Model::ModifyDBParameterGroupOutcome ModifyDBParameterGroup(const Model::ModifyDBParameterGroupRequest& request) const;
 
  template <typename ModifyDBParameterGroupRequestT = Model::ModifyDBParameterGroupRequest>
  Model::ModifyDBParameterGroupOutcomeCallable ModifyDBParameterGroupCallable(const ModifyDBParameterGroupRequestT& request) const {
    return SubmitCallable(&NeptuneClient::ModifyDBParameterGroup, request);
  }
 
  template <typename ModifyDBParameterGroupRequestT = Model::ModifyDBParameterGroupRequest>
  void ModifyDBParameterGroupAsync(const ModifyDBParameterGroupRequestT& request,
                                   const ModifyDBParameterGroupResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::ModifyDBParameterGroup, request, handler, context);
  }
 
  virtual Model::ModifyDBSubnetGroupOutcome ModifyDBSubnetGroup(const Model::ModifyDBSubnetGroupRequest& request) const;
 
  template <typename ModifyDBSubnetGroupRequestT = Model::ModifyDBSubnetGroupRequest>
  Model::ModifyDBSubnetGroupOutcomeCallable ModifyDBSubnetGroupCallable(const ModifyDBSubnetGroupRequestT& request) const {
    return SubmitCallable(&NeptuneClient::ModifyDBSubnetGroup, request);
  }
 
  template <typename ModifyDBSubnetGroupRequestT = Model::ModifyDBSubnetGroupRequest>
  void ModifyDBSubnetGroupAsync(const ModifyDBSubnetGroupRequestT& request, const ModifyDBSubnetGroupResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::ModifyDBSubnetGroup, request, handler, context);
  }
 
  virtual Model::ModifyEventSubscriptionOutcome ModifyEventSubscription(const Model::ModifyEventSubscriptionRequest& request) const;
 
  template <typename ModifyEventSubscriptionRequestT = Model::ModifyEventSubscriptionRequest>
  Model::ModifyEventSubscriptionOutcomeCallable ModifyEventSubscriptionCallable(const ModifyEventSubscriptionRequestT& request) const {
    return SubmitCallable(&NeptuneClient::ModifyEventSubscription, request);
  }
 
  template <typename ModifyEventSubscriptionRequestT = Model::ModifyEventSubscriptionRequest>
  void ModifyEventSubscriptionAsync(const ModifyEventSubscriptionRequestT& request,
                                    const ModifyEventSubscriptionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::ModifyEventSubscription, request, handler, context);
  }
 
  virtual Model::ModifyGlobalClusterOutcome ModifyGlobalCluster(const Model::ModifyGlobalClusterRequest& request) const;
 
  template <typename ModifyGlobalClusterRequestT = Model::ModifyGlobalClusterRequest>
  Model::ModifyGlobalClusterOutcomeCallable ModifyGlobalClusterCallable(const ModifyGlobalClusterRequestT& request) const {
    return SubmitCallable(&NeptuneClient::ModifyGlobalCluster, request);
  }
 
  template <typename ModifyGlobalClusterRequestT = Model::ModifyGlobalClusterRequest>
  void ModifyGlobalClusterAsync(const ModifyGlobalClusterRequestT& request, const ModifyGlobalClusterResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::ModifyGlobalCluster, request, handler, context);
  }
 
  virtual Model::PromoteReadReplicaDBClusterOutcome PromoteReadReplicaDBCluster(
      const Model::PromoteReadReplicaDBClusterRequest& request) const;
 
  template <typename PromoteReadReplicaDBClusterRequestT = Model::PromoteReadReplicaDBClusterRequest>
  Model::PromoteReadReplicaDBClusterOutcomeCallable PromoteReadReplicaDBClusterCallable(
      const PromoteReadReplicaDBClusterRequestT& request) const {
    return SubmitCallable(&NeptuneClient::PromoteReadReplicaDBCluster, request);
  }
 
  template <typename PromoteReadReplicaDBClusterRequestT = Model::PromoteReadReplicaDBClusterRequest>
  void PromoteReadReplicaDBClusterAsync(const PromoteReadReplicaDBClusterRequestT& request,
                                        const PromoteReadReplicaDBClusterResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::PromoteReadReplicaDBCluster, request, handler, context);
  }
 
  virtual Model::RebootDBInstanceOutcome RebootDBInstance(const Model::RebootDBInstanceRequest& request) const;
 
  template <typename RebootDBInstanceRequestT = Model::RebootDBInstanceRequest>
  Model::RebootDBInstanceOutcomeCallable RebootDBInstanceCallable(const RebootDBInstanceRequestT& request) const {
    return SubmitCallable(&NeptuneClient::RebootDBInstance, request);
  }
 
  template <typename RebootDBInstanceRequestT = Model::RebootDBInstanceRequest>
  void RebootDBInstanceAsync(const RebootDBInstanceRequestT& request, const RebootDBInstanceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::RebootDBInstance, request, handler, context);
  }
 
  virtual Model::RemoveFromGlobalClusterOutcome RemoveFromGlobalCluster(const Model::RemoveFromGlobalClusterRequest& request) const;
 
  template <typename RemoveFromGlobalClusterRequestT = Model::RemoveFromGlobalClusterRequest>
  Model::RemoveFromGlobalClusterOutcomeCallable RemoveFromGlobalClusterCallable(const RemoveFromGlobalClusterRequestT& request) const {
    return SubmitCallable(&NeptuneClient::RemoveFromGlobalCluster, request);
  }
 
  template <typename RemoveFromGlobalClusterRequestT = Model::RemoveFromGlobalClusterRequest>
  void RemoveFromGlobalClusterAsync(const RemoveFromGlobalClusterRequestT& request,
                                    const RemoveFromGlobalClusterResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::RemoveFromGlobalCluster, request, handler, context);
  }
 
  virtual Model::RemoveRoleFromDBClusterOutcome RemoveRoleFromDBCluster(const Model::RemoveRoleFromDBClusterRequest& request) const;
 
  template <typename RemoveRoleFromDBClusterRequestT = Model::RemoveRoleFromDBClusterRequest>
  Model::RemoveRoleFromDBClusterOutcomeCallable RemoveRoleFromDBClusterCallable(const RemoveRoleFromDBClusterRequestT& request) const {
    return SubmitCallable(&NeptuneClient::RemoveRoleFromDBCluster, request);
  }
 
  template <typename RemoveRoleFromDBClusterRequestT = Model::RemoveRoleFromDBClusterRequest>
  void RemoveRoleFromDBClusterAsync(const RemoveRoleFromDBClusterRequestT& request,
                                    const RemoveRoleFromDBClusterResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::RemoveRoleFromDBCluster, request, handler, context);
  }
 
  virtual Model::RemoveSourceIdentifierFromSubscriptionOutcome RemoveSourceIdentifierFromSubscription(
      const Model::RemoveSourceIdentifierFromSubscriptionRequest& request) const;
 
  template <typename RemoveSourceIdentifierFromSubscriptionRequestT = Model::RemoveSourceIdentifierFromSubscriptionRequest>
  Model::RemoveSourceIdentifierFromSubscriptionOutcomeCallable RemoveSourceIdentifierFromSubscriptionCallable(
      const RemoveSourceIdentifierFromSubscriptionRequestT& request) const {
    return SubmitCallable(&NeptuneClient::RemoveSourceIdentifierFromSubscription, request);
  }
 
  template <typename RemoveSourceIdentifierFromSubscriptionRequestT = Model::RemoveSourceIdentifierFromSubscriptionRequest>
  void RemoveSourceIdentifierFromSubscriptionAsync(const RemoveSourceIdentifierFromSubscriptionRequestT& request,
                                                   const RemoveSourceIdentifierFromSubscriptionResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::RemoveSourceIdentifierFromSubscription, request, handler, context);
  }
 
  virtual Model::RemoveTagsFromResourceOutcome RemoveTagsFromResource(const Model::RemoveTagsFromResourceRequest& request) const;
 
  template <typename RemoveTagsFromResourceRequestT = Model::RemoveTagsFromResourceRequest>
  Model::RemoveTagsFromResourceOutcomeCallable RemoveTagsFromResourceCallable(const RemoveTagsFromResourceRequestT& request) const {
    return SubmitCallable(&NeptuneClient::RemoveTagsFromResource, request);
  }
 
  template <typename RemoveTagsFromResourceRequestT = Model::RemoveTagsFromResourceRequest>
  void RemoveTagsFromResourceAsync(const RemoveTagsFromResourceRequestT& request,
                                   const RemoveTagsFromResourceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::RemoveTagsFromResource, request, handler, context);
  }
 
  virtual Model::ResetDBClusterParameterGroupOutcome ResetDBClusterParameterGroup(
      const Model::ResetDBClusterParameterGroupRequest& request) const;
 
  template <typename ResetDBClusterParameterGroupRequestT = Model::ResetDBClusterParameterGroupRequest>
  Model::ResetDBClusterParameterGroupOutcomeCallable ResetDBClusterParameterGroupCallable(
      const ResetDBClusterParameterGroupRequestT& request) const {
    return SubmitCallable(&NeptuneClient::ResetDBClusterParameterGroup, request);
  }
 
  template <typename ResetDBClusterParameterGroupRequestT = Model::ResetDBClusterParameterGroupRequest>
  void ResetDBClusterParameterGroupAsync(const ResetDBClusterParameterGroupRequestT& request,
                                         const ResetDBClusterParameterGroupResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::ResetDBClusterParameterGroup, request, handler, context);
  }
 
  virtual Model::ResetDBParameterGroupOutcome ResetDBParameterGroup(const Model::ResetDBParameterGroupRequest& request) const;
 
  template <typename ResetDBParameterGroupRequestT = Model::ResetDBParameterGroupRequest>
  Model::ResetDBParameterGroupOutcomeCallable ResetDBParameterGroupCallable(const ResetDBParameterGroupRequestT& request) const {
    return SubmitCallable(&NeptuneClient::ResetDBParameterGroup, request);
  }
 
  template <typename ResetDBParameterGroupRequestT = Model::ResetDBParameterGroupRequest>
  void ResetDBParameterGroupAsync(const ResetDBParameterGroupRequestT& request, const ResetDBParameterGroupResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::ResetDBParameterGroup, request, handler, context);
  }
 
  virtual Model::RestoreDBClusterFromSnapshotOutcome RestoreDBClusterFromSnapshot(
      const Model::RestoreDBClusterFromSnapshotRequest& request) const;
 
  template <typename RestoreDBClusterFromSnapshotRequestT = Model::RestoreDBClusterFromSnapshotRequest>
  Model::RestoreDBClusterFromSnapshotOutcomeCallable RestoreDBClusterFromSnapshotCallable(
      const RestoreDBClusterFromSnapshotRequestT& request) const {
    return SubmitCallable(&NeptuneClient::RestoreDBClusterFromSnapshot, request);
  }
 
  template <typename RestoreDBClusterFromSnapshotRequestT = Model::RestoreDBClusterFromSnapshotRequest>
  void RestoreDBClusterFromSnapshotAsync(const RestoreDBClusterFromSnapshotRequestT& request,
                                         const RestoreDBClusterFromSnapshotResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::RestoreDBClusterFromSnapshot, request, handler, context);
  }
 
  virtual Model::RestoreDBClusterToPointInTimeOutcome RestoreDBClusterToPointInTime(
      const Model::RestoreDBClusterToPointInTimeRequest& request) const;
 
  template <typename RestoreDBClusterToPointInTimeRequestT = Model::RestoreDBClusterToPointInTimeRequest>
  Model::RestoreDBClusterToPointInTimeOutcomeCallable RestoreDBClusterToPointInTimeCallable(
      const RestoreDBClusterToPointInTimeRequestT& request) const {
    return SubmitCallable(&NeptuneClient::RestoreDBClusterToPointInTime, request);
  }
 
  template <typename RestoreDBClusterToPointInTimeRequestT = Model::RestoreDBClusterToPointInTimeRequest>
  void RestoreDBClusterToPointInTimeAsync(const RestoreDBClusterToPointInTimeRequestT& request,
                                          const RestoreDBClusterToPointInTimeResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::RestoreDBClusterToPointInTime, request, handler, context);
  }
 
  virtual Model::StartDBClusterOutcome StartDBCluster(const Model::StartDBClusterRequest& request) const;
 
  template <typename StartDBClusterRequestT = Model::StartDBClusterRequest>
  Model::StartDBClusterOutcomeCallable StartDBClusterCallable(const StartDBClusterRequestT& request) const {
    return SubmitCallable(&NeptuneClient::StartDBCluster, request);
  }
 
  template <typename StartDBClusterRequestT = Model::StartDBClusterRequest>
  void StartDBClusterAsync(const StartDBClusterRequestT& request, const StartDBClusterResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::StartDBCluster, request, handler, context);
  }
 
  virtual Model::StopDBClusterOutcome StopDBCluster(const Model::StopDBClusterRequest& request) const;
 
  template <typename StopDBClusterRequestT = Model::StopDBClusterRequest>
  Model::StopDBClusterOutcomeCallable StopDBClusterCallable(const StopDBClusterRequestT& request) const {
    return SubmitCallable(&NeptuneClient::StopDBCluster, request);
  }
 
  template <typename StopDBClusterRequestT = Model::StopDBClusterRequest>
  void StopDBClusterAsync(const StopDBClusterRequestT& request, const StopDBClusterResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::StopDBCluster, request, handler, context);
  }
 
  virtual Model::SwitchoverGlobalClusterOutcome SwitchoverGlobalCluster(const Model::SwitchoverGlobalClusterRequest& request) const;
 
  template <typename SwitchoverGlobalClusterRequestT = Model::SwitchoverGlobalClusterRequest>
  Model::SwitchoverGlobalClusterOutcomeCallable SwitchoverGlobalClusterCallable(const SwitchoverGlobalClusterRequestT& request) const {
    return SubmitCallable(&NeptuneClient::SwitchoverGlobalCluster, request);
  }
 
  template <typename SwitchoverGlobalClusterRequestT = Model::SwitchoverGlobalClusterRequest>
  void SwitchoverGlobalClusterAsync(const SwitchoverGlobalClusterRequestT& request,
                                    const SwitchoverGlobalClusterResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NeptuneClient::SwitchoverGlobalCluster, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<NeptuneEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<NeptuneClient>;
  void init(const NeptuneClientConfiguration& clientConfiguration);
 
  NeptuneClientConfiguration m_clientConfiguration;
  std::shared_ptr<NeptuneEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Neptune
}  // namespace Aws