RDSClient.h

 
#pragma once
#include <aws/rds/RDS_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/rds/RDSServiceClientModel.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 CreateGlobalClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateGlobalClusterRequestT& request = {}) 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 ModifyGlobalClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ModifyGlobalClusterRequestT& request = {}) 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 RemoveFromGlobalClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const RemoveFromGlobalClusterRequestT& request = {}) 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