RDSClient.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/rds/RDSServiceClientModel.h>
#include <aws/rds/RDS_EXPORTS.h>
 
namespace Aws {
namespace RDS {
class AWS_RDS_API RDSClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<RDSClient> {
 public:
  typedef Aws::Client::AWSXMLClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef RDSClientConfiguration ClientConfigurationType;
  typedef RDSEndpointProvider EndpointProviderType;
 
  RDSClient(const Aws::RDS::RDSClientConfiguration& clientConfiguration = Aws::RDS::RDSClientConfiguration(),
            std::shared_ptr<RDSEndpointProviderBase> endpointProvider = nullptr);
 
  RDSClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<RDSEndpointProviderBase> endpointProvider = nullptr,
            const Aws::RDS::RDSClientConfiguration& clientConfiguration = Aws::RDS::RDSClientConfiguration());
 
  RDSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            std::shared_ptr<RDSEndpointProviderBase> endpointProvider = nullptr,
            const Aws::RDS::RDSClientConfiguration& clientConfiguration = Aws::RDS::RDSClientConfiguration());
 
  /* Legacy constructors due deprecation */
  RDSClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  RDSClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  RDSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~RDSClient();
 
  Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
  Aws::String GenerateConnectAuthToken(const char* dbHostName, const char* dbRegion, unsigned port, const char* dbUserName) const;
 
  virtual Model::AddRoleToDBClusterOutcome AddRoleToDBCluster(const Model::AddRoleToDBClusterRequest& request) const;
 
  template <typename AddRoleToDBClusterRequestT = Model::AddRoleToDBClusterRequest>
  Model::AddRoleToDBClusterOutcomeCallable AddRoleToDBClusterCallable(const AddRoleToDBClusterRequestT& request) const {
    return SubmitCallable(&RDSClient::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(&RDSClient::AddRoleToDBCluster, request, handler, context);
  }
 
  virtual Model::AddRoleToDBInstanceOutcome AddRoleToDBInstance(const Model::AddRoleToDBInstanceRequest& request) const;
 
  template <typename AddRoleToDBInstanceRequestT = Model::AddRoleToDBInstanceRequest>
  Model::AddRoleToDBInstanceOutcomeCallable AddRoleToDBInstanceCallable(const AddRoleToDBInstanceRequestT& request) const {
    return SubmitCallable(&RDSClient::AddRoleToDBInstance, request);
  }
 
  template <typename AddRoleToDBInstanceRequestT = Model::AddRoleToDBInstanceRequest>
  void AddRoleToDBInstanceAsync(const AddRoleToDBInstanceRequestT& request, const AddRoleToDBInstanceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::AddRoleToDBInstance, 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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::ApplyPendingMaintenanceAction, request, handler, context);
  }
 
  virtual Model::AuthorizeDBSecurityGroupIngressOutcome AuthorizeDBSecurityGroupIngress(
      const Model::AuthorizeDBSecurityGroupIngressRequest& request) const;
 
  template <typename AuthorizeDBSecurityGroupIngressRequestT = Model::AuthorizeDBSecurityGroupIngressRequest>
  Model::AuthorizeDBSecurityGroupIngressOutcomeCallable AuthorizeDBSecurityGroupIngressCallable(
      const AuthorizeDBSecurityGroupIngressRequestT& request) const {
    return SubmitCallable(&RDSClient::AuthorizeDBSecurityGroupIngress, request);
  }
 
  template <typename AuthorizeDBSecurityGroupIngressRequestT = Model::AuthorizeDBSecurityGroupIngressRequest>
  void AuthorizeDBSecurityGroupIngressAsync(const AuthorizeDBSecurityGroupIngressRequestT& request,
                                            const AuthorizeDBSecurityGroupIngressResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::AuthorizeDBSecurityGroupIngress, request, handler, context);
  }
 
  virtual Model::BacktrackDBClusterOutcome BacktrackDBCluster(const Model::BacktrackDBClusterRequest& request) const;
 
  template <typename BacktrackDBClusterRequestT = Model::BacktrackDBClusterRequest>
  Model::BacktrackDBClusterOutcomeCallable BacktrackDBClusterCallable(const BacktrackDBClusterRequestT& request) const {
    return SubmitCallable(&RDSClient::BacktrackDBCluster, request);
  }
 
  template <typename BacktrackDBClusterRequestT = Model::BacktrackDBClusterRequest>
  void BacktrackDBClusterAsync(const BacktrackDBClusterRequestT& request, const BacktrackDBClusterResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::BacktrackDBCluster, request, handler, context);
  }
 
  virtual Model::CancelExportTaskOutcome CancelExportTask(const Model::CancelExportTaskRequest& request) const;
 
  template <typename CancelExportTaskRequestT = Model::CancelExportTaskRequest>
  Model::CancelExportTaskOutcomeCallable CancelExportTaskCallable(const CancelExportTaskRequestT& request) const {
    return SubmitCallable(&RDSClient::CancelExportTask, request);
  }
 
  template <typename CancelExportTaskRequestT = Model::CancelExportTaskRequest>
  void CancelExportTaskAsync(const CancelExportTaskRequestT& request, const CancelExportTaskResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::CancelExportTask, 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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::CopyDBParameterGroup, request, handler, context);
  }
 
  virtual Model::CopyDBSnapshotOutcome CopyDBSnapshot(const Model::CopyDBSnapshotRequest& request) const;
 
  template <typename CopyDBSnapshotRequestT = Model::CopyDBSnapshotRequest>
  Model::CopyDBSnapshotOutcomeCallable CopyDBSnapshotCallable(const CopyDBSnapshotRequestT& request) const {
    return SubmitCallable(&RDSClient::CopyDBSnapshot, request);
  }
 
  template <typename CopyDBSnapshotRequestT = Model::CopyDBSnapshotRequest>
  void CopyDBSnapshotAsync(const CopyDBSnapshotRequestT& request, const CopyDBSnapshotResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::CopyDBSnapshot, request, handler, context);
  }
 
  virtual Model::CopyOptionGroupOutcome CopyOptionGroup(const Model::CopyOptionGroupRequest& request) const;
 
  template <typename CopyOptionGroupRequestT = Model::CopyOptionGroupRequest>
  Model::CopyOptionGroupOutcomeCallable CopyOptionGroupCallable(const CopyOptionGroupRequestT& request) const {
    return SubmitCallable(&RDSClient::CopyOptionGroup, request);
  }
 
  template <typename CopyOptionGroupRequestT = Model::CopyOptionGroupRequest>
  void CopyOptionGroupAsync(const CopyOptionGroupRequestT& request, const CopyOptionGroupResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::CopyOptionGroup, request, handler, context);
  }
 
  virtual Model::CreateBlueGreenDeploymentOutcome CreateBlueGreenDeployment(const Model::CreateBlueGreenDeploymentRequest& request) const;
 
  template <typename CreateBlueGreenDeploymentRequestT = Model::CreateBlueGreenDeploymentRequest>
  Model::CreateBlueGreenDeploymentOutcomeCallable CreateBlueGreenDeploymentCallable(
      const CreateBlueGreenDeploymentRequestT& request) const {
    return SubmitCallable(&RDSClient::CreateBlueGreenDeployment, request);
  }
 
  template <typename CreateBlueGreenDeploymentRequestT = Model::CreateBlueGreenDeploymentRequest>
  void CreateBlueGreenDeploymentAsync(const CreateBlueGreenDeploymentRequestT& request,
                                      const CreateBlueGreenDeploymentResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::CreateBlueGreenDeployment, request, handler, context);
  }
 
  virtual Model::CreateCustomDBEngineVersionOutcome CreateCustomDBEngineVersion(
      const Model::CreateCustomDBEngineVersionRequest& request) const;
 
  template <typename CreateCustomDBEngineVersionRequestT = Model::CreateCustomDBEngineVersionRequest>
  Model::CreateCustomDBEngineVersionOutcomeCallable CreateCustomDBEngineVersionCallable(
      const CreateCustomDBEngineVersionRequestT& request) const {
    return SubmitCallable(&RDSClient::CreateCustomDBEngineVersion, request);
  }
 
  template <typename CreateCustomDBEngineVersionRequestT = Model::CreateCustomDBEngineVersionRequest>
  void CreateCustomDBEngineVersionAsync(const CreateCustomDBEngineVersionRequestT& request,
                                        const CreateCustomDBEngineVersionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::CreateCustomDBEngineVersion, 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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::CreateDBInstance, request, handler, context);
  }
 
  virtual Model::CreateDBInstanceReadReplicaOutcome CreateDBInstanceReadReplica(
      const Model::CreateDBInstanceReadReplicaRequest& request) const;
 
  template <typename CreateDBInstanceReadReplicaRequestT = Model::CreateDBInstanceReadReplicaRequest>
  Model::CreateDBInstanceReadReplicaOutcomeCallable CreateDBInstanceReadReplicaCallable(
      const CreateDBInstanceReadReplicaRequestT& request) const {
    return SubmitCallable(&RDSClient::CreateDBInstanceReadReplica, request);
  }
 
  template <typename CreateDBInstanceReadReplicaRequestT = Model::CreateDBInstanceReadReplicaRequest>
  void CreateDBInstanceReadReplicaAsync(const CreateDBInstanceReadReplicaRequestT& request,
                                        const CreateDBInstanceReadReplicaResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::CreateDBInstanceReadReplica, 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(&RDSClient::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(&RDSClient::CreateDBParameterGroup, request, handler, context);
  }
 
  virtual Model::CreateDBProxyOutcome CreateDBProxy(const Model::CreateDBProxyRequest& request) const;
 
  template <typename CreateDBProxyRequestT = Model::CreateDBProxyRequest>
  Model::CreateDBProxyOutcomeCallable CreateDBProxyCallable(const CreateDBProxyRequestT& request) const {
    return SubmitCallable(&RDSClient::CreateDBProxy, request);
  }
 
  template <typename CreateDBProxyRequestT = Model::CreateDBProxyRequest>
  void CreateDBProxyAsync(const CreateDBProxyRequestT& request, const CreateDBProxyResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::CreateDBProxy, request, handler, context);
  }
 
  virtual Model::CreateDBProxyEndpointOutcome CreateDBProxyEndpoint(const Model::CreateDBProxyEndpointRequest& request) const;
 
  template <typename CreateDBProxyEndpointRequestT = Model::CreateDBProxyEndpointRequest>
  Model::CreateDBProxyEndpointOutcomeCallable CreateDBProxyEndpointCallable(const CreateDBProxyEndpointRequestT& request) const {
    return SubmitCallable(&RDSClient::CreateDBProxyEndpoint, request);
  }
 
  template <typename CreateDBProxyEndpointRequestT = Model::CreateDBProxyEndpointRequest>
  void CreateDBProxyEndpointAsync(const CreateDBProxyEndpointRequestT& request, const CreateDBProxyEndpointResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::CreateDBProxyEndpoint, request, handler, context);
  }
 
  virtual Model::CreateDBSecurityGroupOutcome CreateDBSecurityGroup(const Model::CreateDBSecurityGroupRequest& request) const;
 
  template <typename CreateDBSecurityGroupRequestT = Model::CreateDBSecurityGroupRequest>
  Model::CreateDBSecurityGroupOutcomeCallable CreateDBSecurityGroupCallable(const CreateDBSecurityGroupRequestT& request) const {
    return SubmitCallable(&RDSClient::CreateDBSecurityGroup, request);
  }
 
  template <typename CreateDBSecurityGroupRequestT = Model::CreateDBSecurityGroupRequest>
  void CreateDBSecurityGroupAsync(const CreateDBSecurityGroupRequestT& request, const CreateDBSecurityGroupResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::CreateDBSecurityGroup, request, handler, context);
  }
 
  virtual Model::CreateDBShardGroupOutcome CreateDBShardGroup(const Model::CreateDBShardGroupRequest& request) const;
 
  template <typename CreateDBShardGroupRequestT = Model::CreateDBShardGroupRequest>
  Model::CreateDBShardGroupOutcomeCallable CreateDBShardGroupCallable(const CreateDBShardGroupRequestT& request) const {
    return SubmitCallable(&RDSClient::CreateDBShardGroup, request);
  }
 
  template <typename CreateDBShardGroupRequestT = Model::CreateDBShardGroupRequest>
  void CreateDBShardGroupAsync(const CreateDBShardGroupRequestT& request, const CreateDBShardGroupResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::CreateDBShardGroup, request, handler, context);
  }
 
  virtual Model::CreateDBSnapshotOutcome CreateDBSnapshot(const Model::CreateDBSnapshotRequest& request) const;
 
  template <typename CreateDBSnapshotRequestT = Model::CreateDBSnapshotRequest>
  Model::CreateDBSnapshotOutcomeCallable CreateDBSnapshotCallable(const CreateDBSnapshotRequestT& request) const {
    return SubmitCallable(&RDSClient::CreateDBSnapshot, request);
  }
 
  template <typename CreateDBSnapshotRequestT = Model::CreateDBSnapshotRequest>
  void CreateDBSnapshotAsync(const CreateDBSnapshotRequestT& request, const CreateDBSnapshotResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::CreateDBSnapshot, 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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::CreateGlobalCluster, request, handler, context);
  }
 
  virtual Model::CreateIntegrationOutcome CreateIntegration(const Model::CreateIntegrationRequest& request) const;
 
  template <typename CreateIntegrationRequestT = Model::CreateIntegrationRequest>
  Model::CreateIntegrationOutcomeCallable CreateIntegrationCallable(const CreateIntegrationRequestT& request) const {
    return SubmitCallable(&RDSClient::CreateIntegration, request);
  }
 
  template <typename CreateIntegrationRequestT = Model::CreateIntegrationRequest>
  void CreateIntegrationAsync(const CreateIntegrationRequestT& request, const CreateIntegrationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::CreateIntegration, request, handler, context);
  }
 
  virtual Model::CreateOptionGroupOutcome CreateOptionGroup(const Model::CreateOptionGroupRequest& request) const;
 
  template <typename CreateOptionGroupRequestT = Model::CreateOptionGroupRequest>
  Model::CreateOptionGroupOutcomeCallable CreateOptionGroupCallable(const CreateOptionGroupRequestT& request) const {
    return SubmitCallable(&RDSClient::CreateOptionGroup, request);
  }
 
  template <typename CreateOptionGroupRequestT = Model::CreateOptionGroupRequest>
  void CreateOptionGroupAsync(const CreateOptionGroupRequestT& request, const CreateOptionGroupResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::CreateOptionGroup, request, handler, context);
  }
 
  virtual Model::CreateTenantDatabaseOutcome CreateTenantDatabase(const Model::CreateTenantDatabaseRequest& request) const;
 
  template <typename CreateTenantDatabaseRequestT = Model::CreateTenantDatabaseRequest>
  Model::CreateTenantDatabaseOutcomeCallable CreateTenantDatabaseCallable(const CreateTenantDatabaseRequestT& request) const {
    return SubmitCallable(&RDSClient::CreateTenantDatabase, request);
  }
 
  template <typename CreateTenantDatabaseRequestT = Model::CreateTenantDatabaseRequest>
  void CreateTenantDatabaseAsync(const CreateTenantDatabaseRequestT& request, const CreateTenantDatabaseResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::CreateTenantDatabase, request, handler, context);
  }
 
  virtual Model::DeleteBlueGreenDeploymentOutcome DeleteBlueGreenDeployment(const Model::DeleteBlueGreenDeploymentRequest& request) const;
 
  template <typename DeleteBlueGreenDeploymentRequestT = Model::DeleteBlueGreenDeploymentRequest>
  Model::DeleteBlueGreenDeploymentOutcomeCallable DeleteBlueGreenDeploymentCallable(
      const DeleteBlueGreenDeploymentRequestT& request) const {
    return SubmitCallable(&RDSClient::DeleteBlueGreenDeployment, request);
  }
 
  template <typename DeleteBlueGreenDeploymentRequestT = Model::DeleteBlueGreenDeploymentRequest>
  void DeleteBlueGreenDeploymentAsync(const DeleteBlueGreenDeploymentRequestT& request,
                                      const DeleteBlueGreenDeploymentResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DeleteBlueGreenDeployment, request, handler, context);
  }
 
  virtual Model::DeleteCustomDBEngineVersionOutcome DeleteCustomDBEngineVersion(
      const Model::DeleteCustomDBEngineVersionRequest& request) const;
 
  template <typename DeleteCustomDBEngineVersionRequestT = Model::DeleteCustomDBEngineVersionRequest>
  Model::DeleteCustomDBEngineVersionOutcomeCallable DeleteCustomDBEngineVersionCallable(
      const DeleteCustomDBEngineVersionRequestT& request) const {
    return SubmitCallable(&RDSClient::DeleteCustomDBEngineVersion, request);
  }
 
  template <typename DeleteCustomDBEngineVersionRequestT = Model::DeleteCustomDBEngineVersionRequest>
  void DeleteCustomDBEngineVersionAsync(const DeleteCustomDBEngineVersionRequestT& request,
                                        const DeleteCustomDBEngineVersionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DeleteCustomDBEngineVersion, 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(&RDSClient::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(&RDSClient::DeleteDBCluster, request, handler, context);
  }
 
  virtual Model::DeleteDBClusterAutomatedBackupOutcome DeleteDBClusterAutomatedBackup(
      const Model::DeleteDBClusterAutomatedBackupRequest& request) const;
 
  template <typename DeleteDBClusterAutomatedBackupRequestT = Model::DeleteDBClusterAutomatedBackupRequest>
  Model::DeleteDBClusterAutomatedBackupOutcomeCallable DeleteDBClusterAutomatedBackupCallable(
      const DeleteDBClusterAutomatedBackupRequestT& request) const {
    return SubmitCallable(&RDSClient::DeleteDBClusterAutomatedBackup, request);
  }
 
  template <typename DeleteDBClusterAutomatedBackupRequestT = Model::DeleteDBClusterAutomatedBackupRequest>
  void DeleteDBClusterAutomatedBackupAsync(const DeleteDBClusterAutomatedBackupRequestT& request,
                                           const DeleteDBClusterAutomatedBackupResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DeleteDBClusterAutomatedBackup, 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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::DeleteDBInstance, request, handler, context);
  }
 
  virtual Model::DeleteDBInstanceAutomatedBackupOutcome DeleteDBInstanceAutomatedBackup(
      const Model::DeleteDBInstanceAutomatedBackupRequest& request = {}) const;
 
  template <typename DeleteDBInstanceAutomatedBackupRequestT = Model::DeleteDBInstanceAutomatedBackupRequest>
  Model::DeleteDBInstanceAutomatedBackupOutcomeCallable DeleteDBInstanceAutomatedBackupCallable(
      const DeleteDBInstanceAutomatedBackupRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DeleteDBInstanceAutomatedBackup, request);
  }
 
  template <typename DeleteDBInstanceAutomatedBackupRequestT = Model::DeleteDBInstanceAutomatedBackupRequest>
  void DeleteDBInstanceAutomatedBackupAsync(const DeleteDBInstanceAutomatedBackupResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const DeleteDBInstanceAutomatedBackupRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DeleteDBInstanceAutomatedBackup, 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(&RDSClient::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(&RDSClient::DeleteDBParameterGroup, request, handler, context);
  }
 
  virtual Model::DeleteDBProxyOutcome DeleteDBProxy(const Model::DeleteDBProxyRequest& request) const;
 
  template <typename DeleteDBProxyRequestT = Model::DeleteDBProxyRequest>
  Model::DeleteDBProxyOutcomeCallable DeleteDBProxyCallable(const DeleteDBProxyRequestT& request) const {
    return SubmitCallable(&RDSClient::DeleteDBProxy, request);
  }
 
  template <typename DeleteDBProxyRequestT = Model::DeleteDBProxyRequest>
  void DeleteDBProxyAsync(const DeleteDBProxyRequestT& request, const DeleteDBProxyResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DeleteDBProxy, request, handler, context);
  }
 
  virtual Model::DeleteDBProxyEndpointOutcome DeleteDBProxyEndpoint(const Model::DeleteDBProxyEndpointRequest& request) const;
 
  template <typename DeleteDBProxyEndpointRequestT = Model::DeleteDBProxyEndpointRequest>
  Model::DeleteDBProxyEndpointOutcomeCallable DeleteDBProxyEndpointCallable(const DeleteDBProxyEndpointRequestT& request) const {
    return SubmitCallable(&RDSClient::DeleteDBProxyEndpoint, request);
  }
 
  template <typename DeleteDBProxyEndpointRequestT = Model::DeleteDBProxyEndpointRequest>
  void DeleteDBProxyEndpointAsync(const DeleteDBProxyEndpointRequestT& request, const DeleteDBProxyEndpointResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DeleteDBProxyEndpoint, request, handler, context);
  }
 
  virtual Model::DeleteDBSecurityGroupOutcome DeleteDBSecurityGroup(const Model::DeleteDBSecurityGroupRequest& request) const;
 
  template <typename DeleteDBSecurityGroupRequestT = Model::DeleteDBSecurityGroupRequest>
  Model::DeleteDBSecurityGroupOutcomeCallable DeleteDBSecurityGroupCallable(const DeleteDBSecurityGroupRequestT& request) const {
    return SubmitCallable(&RDSClient::DeleteDBSecurityGroup, request);
  }
 
  template <typename DeleteDBSecurityGroupRequestT = Model::DeleteDBSecurityGroupRequest>
  void DeleteDBSecurityGroupAsync(const DeleteDBSecurityGroupRequestT& request, const DeleteDBSecurityGroupResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DeleteDBSecurityGroup, request, handler, context);
  }
 
  virtual Model::DeleteDBShardGroupOutcome DeleteDBShardGroup(const Model::DeleteDBShardGroupRequest& request) const;
 
  template <typename DeleteDBShardGroupRequestT = Model::DeleteDBShardGroupRequest>
  Model::DeleteDBShardGroupOutcomeCallable DeleteDBShardGroupCallable(const DeleteDBShardGroupRequestT& request) const {
    return SubmitCallable(&RDSClient::DeleteDBShardGroup, request);
  }
 
  template <typename DeleteDBShardGroupRequestT = Model::DeleteDBShardGroupRequest>
  void DeleteDBShardGroupAsync(const DeleteDBShardGroupRequestT& request, const DeleteDBShardGroupResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DeleteDBShardGroup, request, handler, context);
  }
 
  virtual Model::DeleteDBSnapshotOutcome DeleteDBSnapshot(const Model::DeleteDBSnapshotRequest& request) const;
 
  template <typename DeleteDBSnapshotRequestT = Model::DeleteDBSnapshotRequest>
  Model::DeleteDBSnapshotOutcomeCallable DeleteDBSnapshotCallable(const DeleteDBSnapshotRequestT& request) const {
    return SubmitCallable(&RDSClient::DeleteDBSnapshot, request);
  }
 
  template <typename DeleteDBSnapshotRequestT = Model::DeleteDBSnapshotRequest>
  void DeleteDBSnapshotAsync(const DeleteDBSnapshotRequestT& request, const DeleteDBSnapshotResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DeleteDBSnapshot, 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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::DeleteGlobalCluster, request, handler, context);
  }
 
  virtual Model::DeleteIntegrationOutcome DeleteIntegration(const Model::DeleteIntegrationRequest& request) const;
 
  template <typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
  Model::DeleteIntegrationOutcomeCallable DeleteIntegrationCallable(const DeleteIntegrationRequestT& request) const {
    return SubmitCallable(&RDSClient::DeleteIntegration, request);
  }
 
  template <typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
  void DeleteIntegrationAsync(const DeleteIntegrationRequestT& request, const DeleteIntegrationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DeleteIntegration, request, handler, context);
  }
 
  virtual Model::DeleteOptionGroupOutcome DeleteOptionGroup(const Model::DeleteOptionGroupRequest& request) const;
 
  template <typename DeleteOptionGroupRequestT = Model::DeleteOptionGroupRequest>
  Model::DeleteOptionGroupOutcomeCallable DeleteOptionGroupCallable(const DeleteOptionGroupRequestT& request) const {
    return SubmitCallable(&RDSClient::DeleteOptionGroup, request);
  }
 
  template <typename DeleteOptionGroupRequestT = Model::DeleteOptionGroupRequest>
  void DeleteOptionGroupAsync(const DeleteOptionGroupRequestT& request, const DeleteOptionGroupResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DeleteOptionGroup, request, handler, context);
  }
 
  virtual Model::DeleteTenantDatabaseOutcome DeleteTenantDatabase(const Model::DeleteTenantDatabaseRequest& request) const;
 
  template <typename DeleteTenantDatabaseRequestT = Model::DeleteTenantDatabaseRequest>
  Model::DeleteTenantDatabaseOutcomeCallable DeleteTenantDatabaseCallable(const DeleteTenantDatabaseRequestT& request) const {
    return SubmitCallable(&RDSClient::DeleteTenantDatabase, request);
  }
 
  template <typename DeleteTenantDatabaseRequestT = Model::DeleteTenantDatabaseRequest>
  void DeleteTenantDatabaseAsync(const DeleteTenantDatabaseRequestT& request, const DeleteTenantDatabaseResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DeleteTenantDatabase, request, handler, context);
  }
 
  virtual Model::DeregisterDBProxyTargetsOutcome DeregisterDBProxyTargets(const Model::DeregisterDBProxyTargetsRequest& request) const;
 
  template <typename DeregisterDBProxyTargetsRequestT = Model::DeregisterDBProxyTargetsRequest>
  Model::DeregisterDBProxyTargetsOutcomeCallable DeregisterDBProxyTargetsCallable(const DeregisterDBProxyTargetsRequestT& request) const {
    return SubmitCallable(&RDSClient::DeregisterDBProxyTargets, request);
  }
 
  template <typename DeregisterDBProxyTargetsRequestT = Model::DeregisterDBProxyTargetsRequest>
  void DeregisterDBProxyTargetsAsync(const DeregisterDBProxyTargetsRequestT& request,
                                     const DeregisterDBProxyTargetsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DeregisterDBProxyTargets, request, handler, context);
  }
 
  virtual Model::DescribeAccountAttributesOutcome DescribeAccountAttributes(
      const Model::DescribeAccountAttributesRequest& request = {}) const;
 
  template <typename DescribeAccountAttributesRequestT = Model::DescribeAccountAttributesRequest>
  Model::DescribeAccountAttributesOutcomeCallable DescribeAccountAttributesCallable(
      const DescribeAccountAttributesRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeAccountAttributes, request);
  }
 
  template <typename DescribeAccountAttributesRequestT = Model::DescribeAccountAttributesRequest>
  void DescribeAccountAttributesAsync(const DescribeAccountAttributesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeAccountAttributesRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeAccountAttributes, request, handler, context);
  }
 
  virtual Model::DescribeBlueGreenDeploymentsOutcome DescribeBlueGreenDeployments(
      const Model::DescribeBlueGreenDeploymentsRequest& request = {}) const;
 
  template <typename DescribeBlueGreenDeploymentsRequestT = Model::DescribeBlueGreenDeploymentsRequest>
  Model::DescribeBlueGreenDeploymentsOutcomeCallable DescribeBlueGreenDeploymentsCallable(
      const DescribeBlueGreenDeploymentsRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeBlueGreenDeployments, request);
  }
 
  template <typename DescribeBlueGreenDeploymentsRequestT = Model::DescribeBlueGreenDeploymentsRequest>
  void DescribeBlueGreenDeploymentsAsync(const DescribeBlueGreenDeploymentsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeBlueGreenDeploymentsRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeBlueGreenDeployments, 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(&RDSClient::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(&RDSClient::DescribeCertificates, request, handler, context);
  }
 
  virtual Model::DescribeDBClusterAutomatedBackupsOutcome DescribeDBClusterAutomatedBackups(
      const Model::DescribeDBClusterAutomatedBackupsRequest& request = {}) const;
 
  template <typename DescribeDBClusterAutomatedBackupsRequestT = Model::DescribeDBClusterAutomatedBackupsRequest>
  Model::DescribeDBClusterAutomatedBackupsOutcomeCallable DescribeDBClusterAutomatedBackupsCallable(
      const DescribeDBClusterAutomatedBackupsRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeDBClusterAutomatedBackups, request);
  }
 
  template <typename DescribeDBClusterAutomatedBackupsRequestT = Model::DescribeDBClusterAutomatedBackupsRequest>
  void DescribeDBClusterAutomatedBackupsAsync(const DescribeDBClusterAutomatedBackupsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const DescribeDBClusterAutomatedBackupsRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeDBClusterAutomatedBackups, request, handler, context);
  }
 
  virtual Model::DescribeDBClusterBacktracksOutcome DescribeDBClusterBacktracks(
      const Model::DescribeDBClusterBacktracksRequest& request) const;
 
  template <typename DescribeDBClusterBacktracksRequestT = Model::DescribeDBClusterBacktracksRequest>
  Model::DescribeDBClusterBacktracksOutcomeCallable DescribeDBClusterBacktracksCallable(
      const DescribeDBClusterBacktracksRequestT& request) const {
    return SubmitCallable(&RDSClient::DescribeDBClusterBacktracks, request);
  }
 
  template <typename DescribeDBClusterBacktracksRequestT = Model::DescribeDBClusterBacktracksRequest>
  void DescribeDBClusterBacktracksAsync(const DescribeDBClusterBacktracksRequestT& request,
                                        const DescribeDBClusterBacktracksResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DescribeDBClusterBacktracks, 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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::DescribeDBEngineVersions, request, handler, context);
  }
 
  virtual Model::DescribeDBInstanceAutomatedBackupsOutcome DescribeDBInstanceAutomatedBackups(
      const Model::DescribeDBInstanceAutomatedBackupsRequest& request = {}) const;
 
  template <typename DescribeDBInstanceAutomatedBackupsRequestT = Model::DescribeDBInstanceAutomatedBackupsRequest>
  Model::DescribeDBInstanceAutomatedBackupsOutcomeCallable DescribeDBInstanceAutomatedBackupsCallable(
      const DescribeDBInstanceAutomatedBackupsRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeDBInstanceAutomatedBackups, request);
  }
 
  template <typename DescribeDBInstanceAutomatedBackupsRequestT = Model::DescribeDBInstanceAutomatedBackupsRequest>
  void DescribeDBInstanceAutomatedBackupsAsync(const DescribeDBInstanceAutomatedBackupsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DescribeDBInstanceAutomatedBackupsRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeDBInstanceAutomatedBackups, 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(&RDSClient::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(&RDSClient::DescribeDBInstances, request, handler, context);
  }
 
  virtual Model::DescribeDBLogFilesOutcome DescribeDBLogFiles(const Model::DescribeDBLogFilesRequest& request) const;
 
  template <typename DescribeDBLogFilesRequestT = Model::DescribeDBLogFilesRequest>
  Model::DescribeDBLogFilesOutcomeCallable DescribeDBLogFilesCallable(const DescribeDBLogFilesRequestT& request) const {
    return SubmitCallable(&RDSClient::DescribeDBLogFiles, request);
  }
 
  template <typename DescribeDBLogFilesRequestT = Model::DescribeDBLogFilesRequest>
  void DescribeDBLogFilesAsync(const DescribeDBLogFilesRequestT& request, const DescribeDBLogFilesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DescribeDBLogFiles, request, handler, context);
  }
 
  virtual Model::DescribeDBMajorEngineVersionsOutcome DescribeDBMajorEngineVersions(
      const Model::DescribeDBMajorEngineVersionsRequest& request = {}) const;
 
  template <typename DescribeDBMajorEngineVersionsRequestT = Model::DescribeDBMajorEngineVersionsRequest>
  Model::DescribeDBMajorEngineVersionsOutcomeCallable DescribeDBMajorEngineVersionsCallable(
      const DescribeDBMajorEngineVersionsRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeDBMajorEngineVersions, request);
  }
 
  template <typename DescribeDBMajorEngineVersionsRequestT = Model::DescribeDBMajorEngineVersionsRequest>
  void DescribeDBMajorEngineVersionsAsync(const DescribeDBMajorEngineVersionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DescribeDBMajorEngineVersionsRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeDBMajorEngineVersions, 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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::DescribeDBParameters, request, handler, context);
  }
 
  virtual Model::DescribeDBProxiesOutcome DescribeDBProxies(const Model::DescribeDBProxiesRequest& request = {}) const;
 
  template <typename DescribeDBProxiesRequestT = Model::DescribeDBProxiesRequest>
  Model::DescribeDBProxiesOutcomeCallable DescribeDBProxiesCallable(const DescribeDBProxiesRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeDBProxies, request);
  }
 
  template <typename DescribeDBProxiesRequestT = Model::DescribeDBProxiesRequest>
  void DescribeDBProxiesAsync(const DescribeDBProxiesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const DescribeDBProxiesRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeDBProxies, request, handler, context);
  }
 
  virtual Model::DescribeDBProxyEndpointsOutcome DescribeDBProxyEndpoints(const Model::DescribeDBProxyEndpointsRequest& request = {}) const;
 
  template <typename DescribeDBProxyEndpointsRequestT = Model::DescribeDBProxyEndpointsRequest>
  Model::DescribeDBProxyEndpointsOutcomeCallable DescribeDBProxyEndpointsCallable(
      const DescribeDBProxyEndpointsRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeDBProxyEndpoints, request);
  }
 
  template <typename DescribeDBProxyEndpointsRequestT = Model::DescribeDBProxyEndpointsRequest>
  void DescribeDBProxyEndpointsAsync(const DescribeDBProxyEndpointsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeDBProxyEndpointsRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeDBProxyEndpoints, request, handler, context);
  }
 
  virtual Model::DescribeDBProxyTargetGroupsOutcome DescribeDBProxyTargetGroups(
      const Model::DescribeDBProxyTargetGroupsRequest& request) const;
 
  template <typename DescribeDBProxyTargetGroupsRequestT = Model::DescribeDBProxyTargetGroupsRequest>
  Model::DescribeDBProxyTargetGroupsOutcomeCallable DescribeDBProxyTargetGroupsCallable(
      const DescribeDBProxyTargetGroupsRequestT& request) const {
    return SubmitCallable(&RDSClient::DescribeDBProxyTargetGroups, request);
  }
 
  template <typename DescribeDBProxyTargetGroupsRequestT = Model::DescribeDBProxyTargetGroupsRequest>
  void DescribeDBProxyTargetGroupsAsync(const DescribeDBProxyTargetGroupsRequestT& request,
                                        const DescribeDBProxyTargetGroupsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DescribeDBProxyTargetGroups, request, handler, context);
  }
 
  virtual Model::DescribeDBProxyTargetsOutcome DescribeDBProxyTargets(const Model::DescribeDBProxyTargetsRequest& request) const;
 
  template <typename DescribeDBProxyTargetsRequestT = Model::DescribeDBProxyTargetsRequest>
  Model::DescribeDBProxyTargetsOutcomeCallable DescribeDBProxyTargetsCallable(const DescribeDBProxyTargetsRequestT& request) const {
    return SubmitCallable(&RDSClient::DescribeDBProxyTargets, request);
  }
 
  template <typename DescribeDBProxyTargetsRequestT = Model::DescribeDBProxyTargetsRequest>
  void DescribeDBProxyTargetsAsync(const DescribeDBProxyTargetsRequestT& request,
                                   const DescribeDBProxyTargetsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DescribeDBProxyTargets, request, handler, context);
  }
 
  virtual Model::DescribeDBRecommendationsOutcome DescribeDBRecommendations(
      const Model::DescribeDBRecommendationsRequest& request = {}) const;
 
  template <typename DescribeDBRecommendationsRequestT = Model::DescribeDBRecommendationsRequest>
  Model::DescribeDBRecommendationsOutcomeCallable DescribeDBRecommendationsCallable(
      const DescribeDBRecommendationsRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeDBRecommendations, request);
  }
 
  template <typename DescribeDBRecommendationsRequestT = Model::DescribeDBRecommendationsRequest>
  void DescribeDBRecommendationsAsync(const DescribeDBRecommendationsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeDBRecommendationsRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeDBRecommendations, request, handler, context);
  }
 
  virtual Model::DescribeDBSecurityGroupsOutcome DescribeDBSecurityGroups(const Model::DescribeDBSecurityGroupsRequest& request = {}) const;
 
  template <typename DescribeDBSecurityGroupsRequestT = Model::DescribeDBSecurityGroupsRequest>
  Model::DescribeDBSecurityGroupsOutcomeCallable DescribeDBSecurityGroupsCallable(
      const DescribeDBSecurityGroupsRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeDBSecurityGroups, request);
  }
 
  template <typename DescribeDBSecurityGroupsRequestT = Model::DescribeDBSecurityGroupsRequest>
  void DescribeDBSecurityGroupsAsync(const DescribeDBSecurityGroupsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeDBSecurityGroupsRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeDBSecurityGroups, request, handler, context);
  }
 
  virtual Model::DescribeDBShardGroupsOutcome DescribeDBShardGroups(const Model::DescribeDBShardGroupsRequest& request = {}) const;
 
  template <typename DescribeDBShardGroupsRequestT = Model::DescribeDBShardGroupsRequest>
  Model::DescribeDBShardGroupsOutcomeCallable DescribeDBShardGroupsCallable(const DescribeDBShardGroupsRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeDBShardGroups, request);
  }
 
  template <typename DescribeDBShardGroupsRequestT = Model::DescribeDBShardGroupsRequest>
  void DescribeDBShardGroupsAsync(const DescribeDBShardGroupsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const DescribeDBShardGroupsRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeDBShardGroups, request, handler, context);
  }
 
  virtual Model::DescribeDBSnapshotAttributesOutcome DescribeDBSnapshotAttributes(
      const Model::DescribeDBSnapshotAttributesRequest& request) const;
 
  template <typename DescribeDBSnapshotAttributesRequestT = Model::DescribeDBSnapshotAttributesRequest>
  Model::DescribeDBSnapshotAttributesOutcomeCallable DescribeDBSnapshotAttributesCallable(
      const DescribeDBSnapshotAttributesRequestT& request) const {
    return SubmitCallable(&RDSClient::DescribeDBSnapshotAttributes, request);
  }
 
  template <typename DescribeDBSnapshotAttributesRequestT = Model::DescribeDBSnapshotAttributesRequest>
  void DescribeDBSnapshotAttributesAsync(const DescribeDBSnapshotAttributesRequestT& request,
                                         const DescribeDBSnapshotAttributesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DescribeDBSnapshotAttributes, request, handler, context);
  }
 
  virtual Model::DescribeDBSnapshotTenantDatabasesOutcome DescribeDBSnapshotTenantDatabases(
      const Model::DescribeDBSnapshotTenantDatabasesRequest& request = {}) const;
 
  template <typename DescribeDBSnapshotTenantDatabasesRequestT = Model::DescribeDBSnapshotTenantDatabasesRequest>
  Model::DescribeDBSnapshotTenantDatabasesOutcomeCallable DescribeDBSnapshotTenantDatabasesCallable(
      const DescribeDBSnapshotTenantDatabasesRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeDBSnapshotTenantDatabases, request);
  }
 
  template <typename DescribeDBSnapshotTenantDatabasesRequestT = Model::DescribeDBSnapshotTenantDatabasesRequest>
  void DescribeDBSnapshotTenantDatabasesAsync(const DescribeDBSnapshotTenantDatabasesResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const DescribeDBSnapshotTenantDatabasesRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeDBSnapshotTenantDatabases, request, handler, context);
  }
 
  virtual Model::DescribeDBSnapshotsOutcome DescribeDBSnapshots(const Model::DescribeDBSnapshotsRequest& request = {}) const;
 
  template <typename DescribeDBSnapshotsRequestT = Model::DescribeDBSnapshotsRequest>
  Model::DescribeDBSnapshotsOutcomeCallable DescribeDBSnapshotsCallable(const DescribeDBSnapshotsRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeDBSnapshots, request);
  }
 
  template <typename DescribeDBSnapshotsRequestT = Model::DescribeDBSnapshotsRequest>
  void DescribeDBSnapshotsAsync(const DescribeDBSnapshotsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeDBSnapshotsRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeDBSnapshots, 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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::DescribeEvents, request, handler, context);
  }
 
  virtual Model::DescribeExportTasksOutcome DescribeExportTasks(const Model::DescribeExportTasksRequest& request = {}) const;
 
  template <typename DescribeExportTasksRequestT = Model::DescribeExportTasksRequest>
  Model::DescribeExportTasksOutcomeCallable DescribeExportTasksCallable(const DescribeExportTasksRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeExportTasks, request);
  }
 
  template <typename DescribeExportTasksRequestT = Model::DescribeExportTasksRequest>
  void DescribeExportTasksAsync(const DescribeExportTasksResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeExportTasksRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeExportTasks, 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(&RDSClient::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(&RDSClient::DescribeGlobalClusters, request, handler, context);
  }
 
  virtual Model::DescribeIntegrationsOutcome DescribeIntegrations(const Model::DescribeIntegrationsRequest& request = {}) const;
 
  template <typename DescribeIntegrationsRequestT = Model::DescribeIntegrationsRequest>
  Model::DescribeIntegrationsOutcomeCallable DescribeIntegrationsCallable(const DescribeIntegrationsRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeIntegrations, request);
  }
 
  template <typename DescribeIntegrationsRequestT = Model::DescribeIntegrationsRequest>
  void DescribeIntegrationsAsync(const DescribeIntegrationsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeIntegrationsRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeIntegrations, request, handler, context);
  }
 
  virtual Model::DescribeOptionGroupOptionsOutcome DescribeOptionGroupOptions(
      const Model::DescribeOptionGroupOptionsRequest& request) const;
 
  template <typename DescribeOptionGroupOptionsRequestT = Model::DescribeOptionGroupOptionsRequest>
  Model::DescribeOptionGroupOptionsOutcomeCallable DescribeOptionGroupOptionsCallable(
      const DescribeOptionGroupOptionsRequestT& request) const {
    return SubmitCallable(&RDSClient::DescribeOptionGroupOptions, request);
  }
 
  template <typename DescribeOptionGroupOptionsRequestT = Model::DescribeOptionGroupOptionsRequest>
  void DescribeOptionGroupOptionsAsync(const DescribeOptionGroupOptionsRequestT& request,
                                       const DescribeOptionGroupOptionsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DescribeOptionGroupOptions, request, handler, context);
  }
 
  virtual Model::DescribeOptionGroupsOutcome DescribeOptionGroups(const Model::DescribeOptionGroupsRequest& request = {}) const;
 
  template <typename DescribeOptionGroupsRequestT = Model::DescribeOptionGroupsRequest>
  Model::DescribeOptionGroupsOutcomeCallable DescribeOptionGroupsCallable(const DescribeOptionGroupsRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeOptionGroups, request);
  }
 
  template <typename DescribeOptionGroupsRequestT = Model::DescribeOptionGroupsRequest>
  void DescribeOptionGroupsAsync(const DescribeOptionGroupsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeOptionGroupsRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeOptionGroups, 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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::DescribePendingMaintenanceActions, request, handler, context);
  }
 
  virtual Model::DescribeReservedDBInstancesOutcome DescribeReservedDBInstances(
      const Model::DescribeReservedDBInstancesRequest& request = {}) const;
 
  template <typename DescribeReservedDBInstancesRequestT = Model::DescribeReservedDBInstancesRequest>
  Model::DescribeReservedDBInstancesOutcomeCallable DescribeReservedDBInstancesCallable(
      const DescribeReservedDBInstancesRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeReservedDBInstances, request);
  }
 
  template <typename DescribeReservedDBInstancesRequestT = Model::DescribeReservedDBInstancesRequest>
  void DescribeReservedDBInstancesAsync(const DescribeReservedDBInstancesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const DescribeReservedDBInstancesRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeReservedDBInstances, request, handler, context);
  }
 
  virtual Model::DescribeReservedDBInstancesOfferingsOutcome DescribeReservedDBInstancesOfferings(
      const Model::DescribeReservedDBInstancesOfferingsRequest& request = {}) const;
 
  template <typename DescribeReservedDBInstancesOfferingsRequestT = Model::DescribeReservedDBInstancesOfferingsRequest>
  Model::DescribeReservedDBInstancesOfferingsOutcomeCallable DescribeReservedDBInstancesOfferingsCallable(
      const DescribeReservedDBInstancesOfferingsRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeReservedDBInstancesOfferings, request);
  }
 
  template <typename DescribeReservedDBInstancesOfferingsRequestT = Model::DescribeReservedDBInstancesOfferingsRequest>
  void DescribeReservedDBInstancesOfferingsAsync(const DescribeReservedDBInstancesOfferingsResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const DescribeReservedDBInstancesOfferingsRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeReservedDBInstancesOfferings, request, handler, context);
  }
 
  virtual Model::DescribeSourceRegionsOutcome DescribeSourceRegions(const Model::DescribeSourceRegionsRequest& request = {}) const;
 
  template <typename DescribeSourceRegionsRequestT = Model::DescribeSourceRegionsRequest>
  Model::DescribeSourceRegionsOutcomeCallable DescribeSourceRegionsCallable(const DescribeSourceRegionsRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeSourceRegions, request);
  }
 
  template <typename DescribeSourceRegionsRequestT = Model::DescribeSourceRegionsRequest>
  void DescribeSourceRegionsAsync(const DescribeSourceRegionsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const DescribeSourceRegionsRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeSourceRegions, request, handler, context);
  }
 
  virtual Model::DescribeTenantDatabasesOutcome DescribeTenantDatabases(const Model::DescribeTenantDatabasesRequest& request = {}) const;
 
  template <typename DescribeTenantDatabasesRequestT = Model::DescribeTenantDatabasesRequest>
  Model::DescribeTenantDatabasesOutcomeCallable DescribeTenantDatabasesCallable(const DescribeTenantDatabasesRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::DescribeTenantDatabases, request);
  }
 
  template <typename DescribeTenantDatabasesRequestT = Model::DescribeTenantDatabasesRequest>
  void DescribeTenantDatabasesAsync(const DescribeTenantDatabasesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribeTenantDatabasesRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::DescribeTenantDatabases, 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(&RDSClient::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(&RDSClient::DescribeValidDBInstanceModifications, request, handler, context);
  }
 
  virtual Model::DisableHttpEndpointOutcome DisableHttpEndpoint(const Model::DisableHttpEndpointRequest& request) const;
 
  template <typename DisableHttpEndpointRequestT = Model::DisableHttpEndpointRequest>
  Model::DisableHttpEndpointOutcomeCallable DisableHttpEndpointCallable(const DisableHttpEndpointRequestT& request) const {
    return SubmitCallable(&RDSClient::DisableHttpEndpoint, request);
  }
 
  template <typename DisableHttpEndpointRequestT = Model::DisableHttpEndpointRequest>
  void DisableHttpEndpointAsync(const DisableHttpEndpointRequestT& request, const DisableHttpEndpointResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DisableHttpEndpoint, request, handler, context);
  }
 
  virtual Model::DownloadDBLogFilePortionOutcome DownloadDBLogFilePortion(const Model::DownloadDBLogFilePortionRequest& request) const;
 
  template <typename DownloadDBLogFilePortionRequestT = Model::DownloadDBLogFilePortionRequest>
  Model::DownloadDBLogFilePortionOutcomeCallable DownloadDBLogFilePortionCallable(const DownloadDBLogFilePortionRequestT& request) const {
    return SubmitCallable(&RDSClient::DownloadDBLogFilePortion, request);
  }
 
  template <typename DownloadDBLogFilePortionRequestT = Model::DownloadDBLogFilePortionRequest>
  void DownloadDBLogFilePortionAsync(const DownloadDBLogFilePortionRequestT& request,
                                     const DownloadDBLogFilePortionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::DownloadDBLogFilePortion, request, handler, context);
  }
 
  virtual Model::EnableHttpEndpointOutcome EnableHttpEndpoint(const Model::EnableHttpEndpointRequest& request) const;
 
  template <typename EnableHttpEndpointRequestT = Model::EnableHttpEndpointRequest>
  Model::EnableHttpEndpointOutcomeCallable EnableHttpEndpointCallable(const EnableHttpEndpointRequestT& request) const {
    return SubmitCallable(&RDSClient::EnableHttpEndpoint, request);
  }
 
  template <typename EnableHttpEndpointRequestT = Model::EnableHttpEndpointRequest>
  void EnableHttpEndpointAsync(const EnableHttpEndpointRequestT& request, const EnableHttpEndpointResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::EnableHttpEndpoint, 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(&RDSClient::FailoverDBCluster, request);
  }
 
  template <typename FailoverDBClusterRequestT = Model::FailoverDBClusterRequest>
  void FailoverDBClusterAsync(const FailoverDBClusterRequestT& request, const FailoverDBClusterResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ModifyActivityStreamOutcome ModifyActivityStream(const Model::ModifyActivityStreamRequest& request = {}) const;
 
  template <typename ModifyActivityStreamRequestT = Model::ModifyActivityStreamRequest>
  Model::ModifyActivityStreamOutcomeCallable ModifyActivityStreamCallable(const ModifyActivityStreamRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::ModifyActivityStream, request);
  }
 
  template <typename ModifyActivityStreamRequestT = Model::ModifyActivityStreamRequest>
  void ModifyActivityStreamAsync(const ModifyActivityStreamResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ModifyActivityStreamRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::ModifyActivityStream, request, handler, context);
  }
 
  virtual Model::ModifyCertificatesOutcome ModifyCertificates(const Model::ModifyCertificatesRequest& request = {}) const;
 
  template <typename ModifyCertificatesRequestT = Model::ModifyCertificatesRequest>
  Model::ModifyCertificatesOutcomeCallable ModifyCertificatesCallable(const ModifyCertificatesRequestT& request = {}) const {
    return SubmitCallable(&RDSClient::ModifyCertificates, request);
  }
 
  template <typename ModifyCertificatesRequestT = Model::ModifyCertificatesRequest>
  void ModifyCertificatesAsync(const ModifyCertificatesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ModifyCertificatesRequestT& request = {}) const {
    return SubmitAsync(&RDSClient::ModifyCertificates, request, handler, context);
  }
 
  virtual Model::ModifyCurrentDBClusterCapacityOutcome ModifyCurrentDBClusterCapacity(
      const Model::ModifyCurrentDBClusterCapacityRequest& request) const;
 
  template <typename ModifyCurrentDBClusterCapacityRequestT = Model::ModifyCurrentDBClusterCapacityRequest>
  Model::ModifyCurrentDBClusterCapacityOutcomeCallable ModifyCurrentDBClusterCapacityCallable(
      const ModifyCurrentDBClusterCapacityRequestT& request) const {
    return SubmitCallable(&RDSClient::ModifyCurrentDBClusterCapacity, request);
  }
 
  template <typename ModifyCurrentDBClusterCapacityRequestT = Model::ModifyCurrentDBClusterCapacityRequest>
  void ModifyCurrentDBClusterCapacityAsync(const ModifyCurrentDBClusterCapacityRequestT& request,
                                           const ModifyCurrentDBClusterCapacityResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::ModifyCurrentDBClusterCapacity, request, handler, context);
  }
 
  virtual Model::ModifyCustomDBEngineVersionOutcome ModifyCustomDBEngineVersion(
      const Model::ModifyCustomDBEngineVersionRequest& request) const;
 
  template <typename ModifyCustomDBEngineVersionRequestT = Model::ModifyCustomDBEngineVersionRequest>
  Model::ModifyCustomDBEngineVersionOutcomeCallable ModifyCustomDBEngineVersionCallable(
      const ModifyCustomDBEngineVersionRequestT& request) const {
    return SubmitCallable(&RDSClient::ModifyCustomDBEngineVersion, request);
  }
 
  template <typename ModifyCustomDBEngineVersionRequestT = Model::ModifyCustomDBEngineVersionRequest>
  void ModifyCustomDBEngineVersionAsync(const ModifyCustomDBEngineVersionRequestT& request,
                                        const ModifyCustomDBEngineVersionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::ModifyCustomDBEngineVersion, 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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::ModifyDBParameterGroup, request, handler, context);
  }
 
  virtual Model::ModifyDBProxyOutcome ModifyDBProxy(const Model::ModifyDBProxyRequest& request) const;
 
  template <typename ModifyDBProxyRequestT = Model::ModifyDBProxyRequest>
  Model::ModifyDBProxyOutcomeCallable ModifyDBProxyCallable(const ModifyDBProxyRequestT& request) const {
    return SubmitCallable(&RDSClient::ModifyDBProxy, request);
  }
 
  template <typename ModifyDBProxyRequestT = Model::ModifyDBProxyRequest>
  void ModifyDBProxyAsync(const ModifyDBProxyRequestT& request, const ModifyDBProxyResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::ModifyDBProxy, request, handler, context);
  }
 
  virtual Model::ModifyDBProxyEndpointOutcome ModifyDBProxyEndpoint(const Model::ModifyDBProxyEndpointRequest& request) const;
 
  template <typename ModifyDBProxyEndpointRequestT = Model::ModifyDBProxyEndpointRequest>
  Model::ModifyDBProxyEndpointOutcomeCallable ModifyDBProxyEndpointCallable(const ModifyDBProxyEndpointRequestT& request) const {
    return SubmitCallable(&RDSClient::ModifyDBProxyEndpoint, request);
  }
 
  template <typename ModifyDBProxyEndpointRequestT = Model::ModifyDBProxyEndpointRequest>
  void ModifyDBProxyEndpointAsync(const ModifyDBProxyEndpointRequestT& request, const ModifyDBProxyEndpointResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::ModifyDBProxyEndpoint, request, handler, context);
  }
 
  virtual Model::ModifyDBProxyTargetGroupOutcome ModifyDBProxyTargetGroup(const Model::ModifyDBProxyTargetGroupRequest& request) const;
 
  template <typename ModifyDBProxyTargetGroupRequestT = Model::ModifyDBProxyTargetGroupRequest>
  Model::ModifyDBProxyTargetGroupOutcomeCallable ModifyDBProxyTargetGroupCallable(const ModifyDBProxyTargetGroupRequestT& request) const {
    return SubmitCallable(&RDSClient::ModifyDBProxyTargetGroup, request);
  }
 
  template <typename ModifyDBProxyTargetGroupRequestT = Model::ModifyDBProxyTargetGroupRequest>
  void ModifyDBProxyTargetGroupAsync(const ModifyDBProxyTargetGroupRequestT& request,
                                     const ModifyDBProxyTargetGroupResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::ModifyDBProxyTargetGroup, request, handler, context);
  }
 
  virtual Model::ModifyDBRecommendationOutcome ModifyDBRecommendation(const Model::ModifyDBRecommendationRequest& request) const;
 
  template <typename ModifyDBRecommendationRequestT = Model::ModifyDBRecommendationRequest>
  Model::ModifyDBRecommendationOutcomeCallable ModifyDBRecommendationCallable(const ModifyDBRecommendationRequestT& request) const {
    return SubmitCallable(&RDSClient::ModifyDBRecommendation, request);
  }
 
  template <typename ModifyDBRecommendationRequestT = Model::ModifyDBRecommendationRequest>
  void ModifyDBRecommendationAsync(const ModifyDBRecommendationRequestT& request,
                                   const ModifyDBRecommendationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::ModifyDBRecommendation, request, handler, context);
  }
 
  virtual Model::ModifyDBShardGroupOutcome ModifyDBShardGroup(const Model::ModifyDBShardGroupRequest& request) const;
 
  template <typename ModifyDBShardGroupRequestT = Model::ModifyDBShardGroupRequest>
  Model::ModifyDBShardGroupOutcomeCallable ModifyDBShardGroupCallable(const ModifyDBShardGroupRequestT& request) const {
    return SubmitCallable(&RDSClient::ModifyDBShardGroup, request);
  }
 
  template <typename ModifyDBShardGroupRequestT = Model::ModifyDBShardGroupRequest>
  void ModifyDBShardGroupAsync(const ModifyDBShardGroupRequestT& request, const ModifyDBShardGroupResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::ModifyDBShardGroup, request, handler, context);
  }
 
  virtual Model::ModifyDBSnapshotOutcome ModifyDBSnapshot(const Model::ModifyDBSnapshotRequest& request) const;
 
  template <typename ModifyDBSnapshotRequestT = Model::ModifyDBSnapshotRequest>
  Model::ModifyDBSnapshotOutcomeCallable ModifyDBSnapshotCallable(const ModifyDBSnapshotRequestT& request) const {
    return SubmitCallable(&RDSClient::ModifyDBSnapshot, request);
  }
 
  template <typename ModifyDBSnapshotRequestT = Model::ModifyDBSnapshotRequest>
  void ModifyDBSnapshotAsync(const ModifyDBSnapshotRequestT& request, const ModifyDBSnapshotResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::ModifyDBSnapshot, request, handler, context);
  }
 
  virtual Model::ModifyDBSnapshotAttributeOutcome ModifyDBSnapshotAttribute(const Model::ModifyDBSnapshotAttributeRequest& request) const;
 
  template <typename ModifyDBSnapshotAttributeRequestT = Model::ModifyDBSnapshotAttributeRequest>
  Model::ModifyDBSnapshotAttributeOutcomeCallable ModifyDBSnapshotAttributeCallable(
      const ModifyDBSnapshotAttributeRequestT& request) const {
    return SubmitCallable(&RDSClient::ModifyDBSnapshotAttribute, request);
  }
 
  template <typename ModifyDBSnapshotAttributeRequestT = Model::ModifyDBSnapshotAttributeRequest>
  void ModifyDBSnapshotAttributeAsync(const ModifyDBSnapshotAttributeRequestT& request,
                                      const ModifyDBSnapshotAttributeResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::ModifyDBSnapshotAttribute, 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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::ModifyGlobalCluster, request, handler, context);
  }
 
  virtual Model::ModifyIntegrationOutcome ModifyIntegration(const Model::ModifyIntegrationRequest& request) const;
 
  template <typename ModifyIntegrationRequestT = Model::ModifyIntegrationRequest>
  Model::ModifyIntegrationOutcomeCallable ModifyIntegrationCallable(const ModifyIntegrationRequestT& request) const {
    return SubmitCallable(&RDSClient::ModifyIntegration, request);
  }
 
  template <typename ModifyIntegrationRequestT = Model::ModifyIntegrationRequest>
  void ModifyIntegrationAsync(const ModifyIntegrationRequestT& request, const ModifyIntegrationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::ModifyIntegration, request, handler, context);
  }
 
  virtual Model::ModifyOptionGroupOutcome ModifyOptionGroup(const Model::ModifyOptionGroupRequest& request) const;
 
  template <typename ModifyOptionGroupRequestT = Model::ModifyOptionGroupRequest>
  Model::ModifyOptionGroupOutcomeCallable ModifyOptionGroupCallable(const ModifyOptionGroupRequestT& request) const {
    return SubmitCallable(&RDSClient::ModifyOptionGroup, request);
  }
 
  template <typename ModifyOptionGroupRequestT = Model::ModifyOptionGroupRequest>
  void ModifyOptionGroupAsync(const ModifyOptionGroupRequestT& request, const ModifyOptionGroupResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::ModifyOptionGroup, request, handler, context);
  }
 
  virtual Model::ModifyTenantDatabaseOutcome ModifyTenantDatabase(const Model::ModifyTenantDatabaseRequest& request) const;
 
  template <typename ModifyTenantDatabaseRequestT = Model::ModifyTenantDatabaseRequest>
  Model::ModifyTenantDatabaseOutcomeCallable ModifyTenantDatabaseCallable(const ModifyTenantDatabaseRequestT& request) const {
    return SubmitCallable(&RDSClient::ModifyTenantDatabase, request);
  }
 
  template <typename ModifyTenantDatabaseRequestT = Model::ModifyTenantDatabaseRequest>
  void ModifyTenantDatabaseAsync(const ModifyTenantDatabaseRequestT& request, const ModifyTenantDatabaseResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::ModifyTenantDatabase, request, handler, context);
  }
 
  virtual Model::PromoteReadReplicaOutcome PromoteReadReplica(const Model::PromoteReadReplicaRequest& request) const;
 
  template <typename PromoteReadReplicaRequestT = Model::PromoteReadReplicaRequest>
  Model::PromoteReadReplicaOutcomeCallable PromoteReadReplicaCallable(const PromoteReadReplicaRequestT& request) const {
    return SubmitCallable(&RDSClient::PromoteReadReplica, request);
  }
 
  template <typename PromoteReadReplicaRequestT = Model::PromoteReadReplicaRequest>
  void PromoteReadReplicaAsync(const PromoteReadReplicaRequestT& request, const PromoteReadReplicaResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::PromoteReadReplica, 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(&RDSClient::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(&RDSClient::PromoteReadReplicaDBCluster, request, handler, context);
  }
 
  virtual Model::PurchaseReservedDBInstancesOfferingOutcome PurchaseReservedDBInstancesOffering(
      const Model::PurchaseReservedDBInstancesOfferingRequest& request) const;
 
  template <typename PurchaseReservedDBInstancesOfferingRequestT = Model::PurchaseReservedDBInstancesOfferingRequest>
  Model::PurchaseReservedDBInstancesOfferingOutcomeCallable PurchaseReservedDBInstancesOfferingCallable(
      const PurchaseReservedDBInstancesOfferingRequestT& request) const {
    return SubmitCallable(&RDSClient::PurchaseReservedDBInstancesOffering, request);
  }
 
  template <typename PurchaseReservedDBInstancesOfferingRequestT = Model::PurchaseReservedDBInstancesOfferingRequest>
  void PurchaseReservedDBInstancesOfferingAsync(const PurchaseReservedDBInstancesOfferingRequestT& request,
                                                const PurchaseReservedDBInstancesOfferingResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::PurchaseReservedDBInstancesOffering, request, handler, context);
  }
 
  virtual Model::RebootDBClusterOutcome RebootDBCluster(const Model::RebootDBClusterRequest& request) const;
 
  template <typename RebootDBClusterRequestT = Model::RebootDBClusterRequest>
  Model::RebootDBClusterOutcomeCallable RebootDBClusterCallable(const RebootDBClusterRequestT& request) const {
    return SubmitCallable(&RDSClient::RebootDBCluster, request);
  }
 
  template <typename RebootDBClusterRequestT = Model::RebootDBClusterRequest>
  void RebootDBClusterAsync(const RebootDBClusterRequestT& request, const RebootDBClusterResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::RebootDBCluster, 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(&RDSClient::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(&RDSClient::RebootDBInstance, request, handler, context);
  }
 
  virtual Model::RebootDBShardGroupOutcome RebootDBShardGroup(const Model::RebootDBShardGroupRequest& request) const;
 
  template <typename RebootDBShardGroupRequestT = Model::RebootDBShardGroupRequest>
  Model::RebootDBShardGroupOutcomeCallable RebootDBShardGroupCallable(const RebootDBShardGroupRequestT& request) const {
    return SubmitCallable(&RDSClient::RebootDBShardGroup, request);
  }
 
  template <typename RebootDBShardGroupRequestT = Model::RebootDBShardGroupRequest>
  void RebootDBShardGroupAsync(const RebootDBShardGroupRequestT& request, const RebootDBShardGroupResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::RebootDBShardGroup, request, handler, context);
  }
 
  virtual Model::RegisterDBProxyTargetsOutcome RegisterDBProxyTargets(const Model::RegisterDBProxyTargetsRequest& request) const;
 
  template <typename RegisterDBProxyTargetsRequestT = Model::RegisterDBProxyTargetsRequest>
  Model::RegisterDBProxyTargetsOutcomeCallable RegisterDBProxyTargetsCallable(const RegisterDBProxyTargetsRequestT& request) const {
    return SubmitCallable(&RDSClient::RegisterDBProxyTargets, request);
  }
 
  template <typename RegisterDBProxyTargetsRequestT = Model::RegisterDBProxyTargetsRequest>
  void RegisterDBProxyTargetsAsync(const RegisterDBProxyTargetsRequestT& request,
                                   const RegisterDBProxyTargetsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::RegisterDBProxyTargets, 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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::RemoveRoleFromDBCluster, request, handler, context);
  }
 
  virtual Model::RemoveRoleFromDBInstanceOutcome RemoveRoleFromDBInstance(const Model::RemoveRoleFromDBInstanceRequest& request) const;
 
  template <typename RemoveRoleFromDBInstanceRequestT = Model::RemoveRoleFromDBInstanceRequest>
  Model::RemoveRoleFromDBInstanceOutcomeCallable RemoveRoleFromDBInstanceCallable(const RemoveRoleFromDBInstanceRequestT& request) const {
    return SubmitCallable(&RDSClient::RemoveRoleFromDBInstance, request);
  }
 
  template <typename RemoveRoleFromDBInstanceRequestT = Model::RemoveRoleFromDBInstanceRequest>
  void RemoveRoleFromDBInstanceAsync(const RemoveRoleFromDBInstanceRequestT& request,
                                     const RemoveRoleFromDBInstanceResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::RemoveRoleFromDBInstance, 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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::ResetDBParameterGroup, request, handler, context);
  }
 
  virtual Model::RestoreDBClusterFromS3Outcome RestoreDBClusterFromS3(const Model::RestoreDBClusterFromS3Request& request) const;
 
  template <typename RestoreDBClusterFromS3RequestT = Model::RestoreDBClusterFromS3Request>
  Model::RestoreDBClusterFromS3OutcomeCallable RestoreDBClusterFromS3Callable(const RestoreDBClusterFromS3RequestT& request) const {
    return SubmitCallable(&RDSClient::RestoreDBClusterFromS3, request);
  }
 
  template <typename RestoreDBClusterFromS3RequestT = Model::RestoreDBClusterFromS3Request>
  void RestoreDBClusterFromS3Async(const RestoreDBClusterFromS3RequestT& request,
                                   const RestoreDBClusterFromS3ResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::RestoreDBClusterFromS3, 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(&RDSClient::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(&RDSClient::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(&RDSClient::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(&RDSClient::RestoreDBClusterToPointInTime, request, handler, context);
  }
 
  virtual Model::RestoreDBInstanceFromDBSnapshotOutcome RestoreDBInstanceFromDBSnapshot(
      const Model::RestoreDBInstanceFromDBSnapshotRequest& request) const;
 
  template <typename RestoreDBInstanceFromDBSnapshotRequestT = Model::RestoreDBInstanceFromDBSnapshotRequest>
  Model::RestoreDBInstanceFromDBSnapshotOutcomeCallable RestoreDBInstanceFromDBSnapshotCallable(
      const RestoreDBInstanceFromDBSnapshotRequestT& request) const {
    return SubmitCallable(&RDSClient::RestoreDBInstanceFromDBSnapshot, request);
  }
 
  template <typename RestoreDBInstanceFromDBSnapshotRequestT = Model::RestoreDBInstanceFromDBSnapshotRequest>
  void RestoreDBInstanceFromDBSnapshotAsync(const RestoreDBInstanceFromDBSnapshotRequestT& request,
                                            const RestoreDBInstanceFromDBSnapshotResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::RestoreDBInstanceFromDBSnapshot, request, handler, context);
  }
 
  virtual Model::RestoreDBInstanceFromS3Outcome RestoreDBInstanceFromS3(const Model::RestoreDBInstanceFromS3Request& request) const;
 
  template <typename RestoreDBInstanceFromS3RequestT = Model::RestoreDBInstanceFromS3Request>
  Model::RestoreDBInstanceFromS3OutcomeCallable RestoreDBInstanceFromS3Callable(const RestoreDBInstanceFromS3RequestT& request) const {
    return SubmitCallable(&RDSClient::RestoreDBInstanceFromS3, request);
  }
 
  template <typename RestoreDBInstanceFromS3RequestT = Model::RestoreDBInstanceFromS3Request>
  void RestoreDBInstanceFromS3Async(const RestoreDBInstanceFromS3RequestT& request,
                                    const RestoreDBInstanceFromS3ResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::RestoreDBInstanceFromS3, request, handler, context);
  }
 
  virtual Model::RestoreDBInstanceToPointInTimeOutcome RestoreDBInstanceToPointInTime(
      const Model::RestoreDBInstanceToPointInTimeRequest& request) const;
 
  template <typename RestoreDBInstanceToPointInTimeRequestT = Model::RestoreDBInstanceToPointInTimeRequest>
  Model::RestoreDBInstanceToPointInTimeOutcomeCallable RestoreDBInstanceToPointInTimeCallable(
      const RestoreDBInstanceToPointInTimeRequestT& request) const {
    return SubmitCallable(&RDSClient::RestoreDBInstanceToPointInTime, request);
  }
 
  template <typename RestoreDBInstanceToPointInTimeRequestT = Model::RestoreDBInstanceToPointInTimeRequest>
  void RestoreDBInstanceToPointInTimeAsync(const RestoreDBInstanceToPointInTimeRequestT& request,
                                           const RestoreDBInstanceToPointInTimeResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::RestoreDBInstanceToPointInTime, request, handler, context);
  }
 
  virtual Model::RevokeDBSecurityGroupIngressOutcome RevokeDBSecurityGroupIngress(
      const Model::RevokeDBSecurityGroupIngressRequest& request) const;
 
  template <typename RevokeDBSecurityGroupIngressRequestT = Model::RevokeDBSecurityGroupIngressRequest>
  Model::RevokeDBSecurityGroupIngressOutcomeCallable RevokeDBSecurityGroupIngressCallable(
      const RevokeDBSecurityGroupIngressRequestT& request) const {
    return SubmitCallable(&RDSClient::RevokeDBSecurityGroupIngress, request);
  }
 
  template <typename RevokeDBSecurityGroupIngressRequestT = Model::RevokeDBSecurityGroupIngressRequest>
  void RevokeDBSecurityGroupIngressAsync(const RevokeDBSecurityGroupIngressRequestT& request,
                                         const RevokeDBSecurityGroupIngressResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::RevokeDBSecurityGroupIngress, request, handler, context);
  }
 
  virtual Model::StartActivityStreamOutcome StartActivityStream(const Model::StartActivityStreamRequest& request) const;
 
  template <typename StartActivityStreamRequestT = Model::StartActivityStreamRequest>
  Model::StartActivityStreamOutcomeCallable StartActivityStreamCallable(const StartActivityStreamRequestT& request) const {
    return SubmitCallable(&RDSClient::StartActivityStream, request);
  }
 
  template <typename StartActivityStreamRequestT = Model::StartActivityStreamRequest>
  void StartActivityStreamAsync(const StartActivityStreamRequestT& request, const StartActivityStreamResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::StartActivityStream, 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(&RDSClient::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(&RDSClient::StartDBCluster, request, handler, context);
  }
 
  virtual Model::StartDBInstanceOutcome StartDBInstance(const Model::StartDBInstanceRequest& request) const;
 
  template <typename StartDBInstanceRequestT = Model::StartDBInstanceRequest>
  Model::StartDBInstanceOutcomeCallable StartDBInstanceCallable(const StartDBInstanceRequestT& request) const {
    return SubmitCallable(&RDSClient::StartDBInstance, request);
  }
 
  template <typename StartDBInstanceRequestT = Model::StartDBInstanceRequest>
  void StartDBInstanceAsync(const StartDBInstanceRequestT& request, const StartDBInstanceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::StartDBInstance, request, handler, context);
  }
 
  virtual Model::StartDBInstanceAutomatedBackupsReplicationOutcome StartDBInstanceAutomatedBackupsReplication(
      const Model::StartDBInstanceAutomatedBackupsReplicationRequest& request) const;
 
  template <typename StartDBInstanceAutomatedBackupsReplicationRequestT = Model::StartDBInstanceAutomatedBackupsReplicationRequest>
  Model::StartDBInstanceAutomatedBackupsReplicationOutcomeCallable StartDBInstanceAutomatedBackupsReplicationCallable(
      const StartDBInstanceAutomatedBackupsReplicationRequestT& request) const {
    return SubmitCallable(&RDSClient::StartDBInstanceAutomatedBackupsReplication, request);
  }
 
  template <typename StartDBInstanceAutomatedBackupsReplicationRequestT = Model::StartDBInstanceAutomatedBackupsReplicationRequest>
  void StartDBInstanceAutomatedBackupsReplicationAsync(
      const StartDBInstanceAutomatedBackupsReplicationRequestT& request,
      const StartDBInstanceAutomatedBackupsReplicationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::StartDBInstanceAutomatedBackupsReplication, request, handler, context);
  }
 
  virtual Model::StartExportTaskOutcome StartExportTask(const Model::StartExportTaskRequest& request) const;
 
  template <typename StartExportTaskRequestT = Model::StartExportTaskRequest>
  Model::StartExportTaskOutcomeCallable StartExportTaskCallable(const StartExportTaskRequestT& request) const {
    return SubmitCallable(&RDSClient::StartExportTask, request);
  }
 
  template <typename StartExportTaskRequestT = Model::StartExportTaskRequest>
  void StartExportTaskAsync(const StartExportTaskRequestT& request, const StartExportTaskResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::StartExportTask, request, handler, context);
  }
 
  virtual Model::StopActivityStreamOutcome StopActivityStream(const Model::StopActivityStreamRequest& request) const;
 
  template <typename StopActivityStreamRequestT = Model::StopActivityStreamRequest>
  Model::StopActivityStreamOutcomeCallable StopActivityStreamCallable(const StopActivityStreamRequestT& request) const {
    return SubmitCallable(&RDSClient::StopActivityStream, request);
  }
 
  template <typename StopActivityStreamRequestT = Model::StopActivityStreamRequest>
  void StopActivityStreamAsync(const StopActivityStreamRequestT& request, const StopActivityStreamResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::StopActivityStream, 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(&RDSClient::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(&RDSClient::StopDBCluster, request, handler, context);
  }
 
  virtual Model::StopDBInstanceOutcome StopDBInstance(const Model::StopDBInstanceRequest& request) const;
 
  template <typename StopDBInstanceRequestT = Model::StopDBInstanceRequest>
  Model::StopDBInstanceOutcomeCallable StopDBInstanceCallable(const StopDBInstanceRequestT& request) const {
    return SubmitCallable(&RDSClient::StopDBInstance, request);
  }
 
  template <typename StopDBInstanceRequestT = Model::StopDBInstanceRequest>
  void StopDBInstanceAsync(const StopDBInstanceRequestT& request, const StopDBInstanceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::StopDBInstance, request, handler, context);
  }
 
  virtual Model::StopDBInstanceAutomatedBackupsReplicationOutcome StopDBInstanceAutomatedBackupsReplication(
      const Model::StopDBInstanceAutomatedBackupsReplicationRequest& request) const;
 
  template <typename StopDBInstanceAutomatedBackupsReplicationRequestT = Model::StopDBInstanceAutomatedBackupsReplicationRequest>
  Model::StopDBInstanceAutomatedBackupsReplicationOutcomeCallable StopDBInstanceAutomatedBackupsReplicationCallable(
      const StopDBInstanceAutomatedBackupsReplicationRequestT& request) const {
    return SubmitCallable(&RDSClient::StopDBInstanceAutomatedBackupsReplication, request);
  }
 
  template <typename StopDBInstanceAutomatedBackupsReplicationRequestT = Model::StopDBInstanceAutomatedBackupsReplicationRequest>
  void StopDBInstanceAutomatedBackupsReplicationAsync(
      const StopDBInstanceAutomatedBackupsReplicationRequestT& request,
      const StopDBInstanceAutomatedBackupsReplicationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::StopDBInstanceAutomatedBackupsReplication, request, handler, context);
  }
 
  virtual Model::SwitchoverBlueGreenDeploymentOutcome SwitchoverBlueGreenDeployment(
      const Model::SwitchoverBlueGreenDeploymentRequest& request) const;
 
  template <typename SwitchoverBlueGreenDeploymentRequestT = Model::SwitchoverBlueGreenDeploymentRequest>
  Model::SwitchoverBlueGreenDeploymentOutcomeCallable SwitchoverBlueGreenDeploymentCallable(
      const SwitchoverBlueGreenDeploymentRequestT& request) const {
    return SubmitCallable(&RDSClient::SwitchoverBlueGreenDeployment, request);
  }
 
  template <typename SwitchoverBlueGreenDeploymentRequestT = Model::SwitchoverBlueGreenDeploymentRequest>
  void SwitchoverBlueGreenDeploymentAsync(const SwitchoverBlueGreenDeploymentRequestT& request,
                                          const SwitchoverBlueGreenDeploymentResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::SwitchoverBlueGreenDeployment, 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(&RDSClient::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(&RDSClient::SwitchoverGlobalCluster, request, handler, context);
  }
 
  virtual Model::SwitchoverReadReplicaOutcome SwitchoverReadReplica(const Model::SwitchoverReadReplicaRequest& request) const;
 
  template <typename SwitchoverReadReplicaRequestT = Model::SwitchoverReadReplicaRequest>
  Model::SwitchoverReadReplicaOutcomeCallable SwitchoverReadReplicaCallable(const SwitchoverReadReplicaRequestT& request) const {
    return SubmitCallable(&RDSClient::SwitchoverReadReplica, request);
  }
 
  template <typename SwitchoverReadReplicaRequestT = Model::SwitchoverReadReplicaRequest>
  void SwitchoverReadReplicaAsync(const SwitchoverReadReplicaRequestT& request, const SwitchoverReadReplicaResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RDSClient::SwitchoverReadReplica, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<RDSEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<RDSClient>;
  void init(const RDSClientConfiguration& clientConfiguration);
 
  RDSClientConfiguration m_clientConfiguration;
  std::shared_ptr<RDSEndpointProviderBase> m_endpointProvider;
};
}  // namespace RDS
}  // namespace Aws