DocDBClient.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/docdb/DocDBServiceClientModel.h>
#include <aws/docdb/DocDB_EXPORTS.h>
 
namespace Aws {
namespace DocDB {
class AWS_DOCDB_API DocDBClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<DocDBClient> {
 public:
  typedef Aws::Client::AWSXMLClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef DocDBClientConfiguration ClientConfigurationType;
  typedef DocDBEndpointProvider EndpointProviderType;
 
  DocDBClient(const Aws::DocDB::DocDBClientConfiguration& clientConfiguration = Aws::DocDB::DocDBClientConfiguration(),
              std::shared_ptr<DocDBEndpointProviderBase> endpointProvider = nullptr);
 
  DocDBClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<DocDBEndpointProviderBase> endpointProvider = nullptr,
              const Aws::DocDB::DocDBClientConfiguration& clientConfiguration = Aws::DocDB::DocDBClientConfiguration());
 
  DocDBClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
              std::shared_ptr<DocDBEndpointProviderBase> endpointProvider = nullptr,
              const Aws::DocDB::DocDBClientConfiguration& clientConfiguration = Aws::DocDB::DocDBClientConfiguration());
 
  /* Legacy constructors due deprecation */
  DocDBClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DocDBClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DocDBClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
              const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~DocDBClient();
 
  Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
  virtual Model::AddSourceIdentifierToSubscriptionOutcome AddSourceIdentifierToSubscription(
      const Model::AddSourceIdentifierToSubscriptionRequest& request) const;
 
  template <typename AddSourceIdentifierToSubscriptionRequestT = Model::AddSourceIdentifierToSubscriptionRequest>
  Model::AddSourceIdentifierToSubscriptionOutcomeCallable AddSourceIdentifierToSubscriptionCallable(
      const AddSourceIdentifierToSubscriptionRequestT& request) const {
    return SubmitCallable(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::CopyDBClusterSnapshot, 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(&DocDBClient::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(&DocDBClient::CreateDBCluster, 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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::CreateDBInstance, 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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::DeleteDBCluster, 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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::DeleteDBInstance, 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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::DeleteGlobalCluster, request, handler, context);
  }
 
  virtual Model::DescribeCertificatesOutcome DescribeCertificates(const Model::DescribeCertificatesRequest& request = {}) const;
 
  template <typename DescribeCertificatesRequestT = Model::DescribeCertificatesRequest>
  Model::DescribeCertificatesOutcomeCallable DescribeCertificatesCallable(const DescribeCertificatesRequestT& request = {}) const {
    return SubmitCallable(&DocDBClient::DescribeCertificates, request);
  }
 
  template <typename DescribeCertificatesRequestT = Model::DescribeCertificatesRequest>
  void DescribeCertificatesAsync(const DescribeCertificatesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeCertificatesRequestT& request = {}) const {
    return SubmitAsync(&DocDBClient::DescribeCertificates, 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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::DescribeDBInstances, 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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::DescribeEngineDefaultClusterParameters, 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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::DescribePendingMaintenanceActions, 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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::ModifyDBCluster, 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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::ModifyDBInstance, 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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::ModifyGlobalCluster, 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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::RemoveFromGlobalCluster, 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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::ResetDBClusterParameterGroup, 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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::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(&DocDBClient::SwitchoverGlobalCluster, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<DocDBEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<DocDBClient>;
  void init(const DocDBClientConfiguration& clientConfiguration);
 
  DocDBClientConfiguration m_clientConfiguration;
  std::shared_ptr<DocDBEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace DocDB
}  // namespace Aws