DatabaseMigrationServiceClient.h

 
#pragma once
#include <aws/dms/DatabaseMigrationService_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/dms/DatabaseMigrationServiceServiceClientModel.h>
 
namespace Aws
{
namespace DatabaseMigrationService
{
  class AWS_DATABASEMIGRATIONSERVICE_API DatabaseMigrationServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<DatabaseMigrationServiceClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef DatabaseMigrationServiceClientConfiguration ClientConfigurationType;
      typedef DatabaseMigrationServiceEndpointProvider EndpointProviderType;
 
        DatabaseMigrationServiceClient(const Aws::DatabaseMigrationService::DatabaseMigrationServiceClientConfiguration& clientConfiguration = Aws::DatabaseMigrationService::DatabaseMigrationServiceClientConfiguration(),
                                       std::shared_ptr<DatabaseMigrationServiceEndpointProviderBase> endpointProvider = nullptr);
 
        DatabaseMigrationServiceClient(const Aws::Auth::AWSCredentials& credentials,
                                       std::shared_ptr<DatabaseMigrationServiceEndpointProviderBase> endpointProvider = nullptr,
                                       const Aws::DatabaseMigrationService::DatabaseMigrationServiceClientConfiguration& clientConfiguration = Aws::DatabaseMigrationService::DatabaseMigrationServiceClientConfiguration());
 
        DatabaseMigrationServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                       std::shared_ptr<DatabaseMigrationServiceEndpointProviderBase> endpointProvider = nullptr,
                                       const Aws::DatabaseMigrationService::DatabaseMigrationServiceClientConfiguration& clientConfiguration = Aws::DatabaseMigrationService::DatabaseMigrationServiceClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        DatabaseMigrationServiceClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        DatabaseMigrationServiceClient(const Aws::Auth::AWSCredentials& credentials,
                                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        DatabaseMigrationServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~DatabaseMigrationServiceClient();
 
        virtual Model::AddTagsToResourceOutcome AddTagsToResource(const Model::AddTagsToResourceRequest& request) const;
 
        template<typename AddTagsToResourceRequestT = Model::AddTagsToResourceRequest>
        Model::AddTagsToResourceOutcomeCallable AddTagsToResourceCallable(const AddTagsToResourceRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::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(&DatabaseMigrationServiceClient::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(&DatabaseMigrationServiceClient::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(&DatabaseMigrationServiceClient::ApplyPendingMaintenanceAction, request, handler, context);
        }
 
        virtual Model::BatchStartRecommendationsOutcome BatchStartRecommendations(const Model::BatchStartRecommendationsRequest& request = {}) const;
 
        template<typename BatchStartRecommendationsRequestT = Model::BatchStartRecommendationsRequest>
        Model::BatchStartRecommendationsOutcomeCallable BatchStartRecommendationsCallable(const BatchStartRecommendationsRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::BatchStartRecommendations, request);
        }
 
        template<typename BatchStartRecommendationsRequestT = Model::BatchStartRecommendationsRequest>
        void BatchStartRecommendationsAsync(const BatchStartRecommendationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const BatchStartRecommendationsRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::BatchStartRecommendations, request, handler, context);
        }
 
        virtual Model::CancelReplicationTaskAssessmentRunOutcome CancelReplicationTaskAssessmentRun(const Model::CancelReplicationTaskAssessmentRunRequest& request) const;
 
        template<typename CancelReplicationTaskAssessmentRunRequestT = Model::CancelReplicationTaskAssessmentRunRequest>
        Model::CancelReplicationTaskAssessmentRunOutcomeCallable CancelReplicationTaskAssessmentRunCallable(const CancelReplicationTaskAssessmentRunRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::CancelReplicationTaskAssessmentRun, request);
        }
 
        template<typename CancelReplicationTaskAssessmentRunRequestT = Model::CancelReplicationTaskAssessmentRunRequest>
        void CancelReplicationTaskAssessmentRunAsync(const CancelReplicationTaskAssessmentRunRequestT& request, const CancelReplicationTaskAssessmentRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::CancelReplicationTaskAssessmentRun, request, handler, context);
        }
 
        virtual Model::CreateDataMigrationOutcome CreateDataMigration(const Model::CreateDataMigrationRequest& request) const;
 
        template<typename CreateDataMigrationRequestT = Model::CreateDataMigrationRequest>
        Model::CreateDataMigrationOutcomeCallable CreateDataMigrationCallable(const CreateDataMigrationRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::CreateDataMigration, request);
        }
 
        template<typename CreateDataMigrationRequestT = Model::CreateDataMigrationRequest>
        void CreateDataMigrationAsync(const CreateDataMigrationRequestT& request, const CreateDataMigrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::CreateDataMigration, request, handler, context);
        }
 
        virtual Model::CreateDataProviderOutcome CreateDataProvider(const Model::CreateDataProviderRequest& request) const;
 
        template<typename CreateDataProviderRequestT = Model::CreateDataProviderRequest>
        Model::CreateDataProviderOutcomeCallable CreateDataProviderCallable(const CreateDataProviderRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::CreateDataProvider, request);
        }
 
        template<typename CreateDataProviderRequestT = Model::CreateDataProviderRequest>
        void CreateDataProviderAsync(const CreateDataProviderRequestT& request, const CreateDataProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::CreateDataProvider, request, handler, context);
        }
 
        virtual Model::CreateEndpointOutcome CreateEndpoint(const Model::CreateEndpointRequest& request) const;
 
        template<typename CreateEndpointRequestT = Model::CreateEndpointRequest>
        Model::CreateEndpointOutcomeCallable CreateEndpointCallable(const CreateEndpointRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::CreateEndpoint, request);
        }
 
        template<typename CreateEndpointRequestT = Model::CreateEndpointRequest>
        void CreateEndpointAsync(const CreateEndpointRequestT& request, const CreateEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::CreateEndpoint, 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(&DatabaseMigrationServiceClient::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(&DatabaseMigrationServiceClient::CreateEventSubscription, request, handler, context);
        }
 
        virtual Model::CreateFleetAdvisorCollectorOutcome CreateFleetAdvisorCollector(const Model::CreateFleetAdvisorCollectorRequest& request) const;
 
        template<typename CreateFleetAdvisorCollectorRequestT = Model::CreateFleetAdvisorCollectorRequest>
        Model::CreateFleetAdvisorCollectorOutcomeCallable CreateFleetAdvisorCollectorCallable(const CreateFleetAdvisorCollectorRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::CreateFleetAdvisorCollector, request);
        }
 
        template<typename CreateFleetAdvisorCollectorRequestT = Model::CreateFleetAdvisorCollectorRequest>
        void CreateFleetAdvisorCollectorAsync(const CreateFleetAdvisorCollectorRequestT& request, const CreateFleetAdvisorCollectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::CreateFleetAdvisorCollector, request, handler, context);
        }
 
        virtual Model::CreateInstanceProfileOutcome CreateInstanceProfile(const Model::CreateInstanceProfileRequest& request = {}) const;
 
        template<typename CreateInstanceProfileRequestT = Model::CreateInstanceProfileRequest>
        Model::CreateInstanceProfileOutcomeCallable CreateInstanceProfileCallable(const CreateInstanceProfileRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::CreateInstanceProfile, request);
        }
 
        template<typename CreateInstanceProfileRequestT = Model::CreateInstanceProfileRequest>
        void CreateInstanceProfileAsync(const CreateInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateInstanceProfileRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::CreateInstanceProfile, request, handler, context);
        }
 
        virtual Model::CreateMigrationProjectOutcome CreateMigrationProject(const Model::CreateMigrationProjectRequest& request) const;
 
        template<typename CreateMigrationProjectRequestT = Model::CreateMigrationProjectRequest>
        Model::CreateMigrationProjectOutcomeCallable CreateMigrationProjectCallable(const CreateMigrationProjectRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::CreateMigrationProject, request);
        }
 
        template<typename CreateMigrationProjectRequestT = Model::CreateMigrationProjectRequest>
        void CreateMigrationProjectAsync(const CreateMigrationProjectRequestT& request, const CreateMigrationProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::CreateMigrationProject, request, handler, context);
        }
 
        virtual Model::CreateReplicationConfigOutcome CreateReplicationConfig(const Model::CreateReplicationConfigRequest& request) const;
 
        template<typename CreateReplicationConfigRequestT = Model::CreateReplicationConfigRequest>
        Model::CreateReplicationConfigOutcomeCallable CreateReplicationConfigCallable(const CreateReplicationConfigRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::CreateReplicationConfig, request);
        }
 
        template<typename CreateReplicationConfigRequestT = Model::CreateReplicationConfigRequest>
        void CreateReplicationConfigAsync(const CreateReplicationConfigRequestT& request, const CreateReplicationConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::CreateReplicationConfig, request, handler, context);
        }
 
        virtual Model::CreateReplicationInstanceOutcome CreateReplicationInstance(const Model::CreateReplicationInstanceRequest& request) const;
 
        template<typename CreateReplicationInstanceRequestT = Model::CreateReplicationInstanceRequest>
        Model::CreateReplicationInstanceOutcomeCallable CreateReplicationInstanceCallable(const CreateReplicationInstanceRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::CreateReplicationInstance, request);
        }
 
        template<typename CreateReplicationInstanceRequestT = Model::CreateReplicationInstanceRequest>
        void CreateReplicationInstanceAsync(const CreateReplicationInstanceRequestT& request, const CreateReplicationInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::CreateReplicationInstance, request, handler, context);
        }
 
        virtual Model::CreateReplicationSubnetGroupOutcome CreateReplicationSubnetGroup(const Model::CreateReplicationSubnetGroupRequest& request) const;
 
        template<typename CreateReplicationSubnetGroupRequestT = Model::CreateReplicationSubnetGroupRequest>
        Model::CreateReplicationSubnetGroupOutcomeCallable CreateReplicationSubnetGroupCallable(const CreateReplicationSubnetGroupRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::CreateReplicationSubnetGroup, request);
        }
 
        template<typename CreateReplicationSubnetGroupRequestT = Model::CreateReplicationSubnetGroupRequest>
        void CreateReplicationSubnetGroupAsync(const CreateReplicationSubnetGroupRequestT& request, const CreateReplicationSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::CreateReplicationSubnetGroup, request, handler, context);
        }
 
        virtual Model::CreateReplicationTaskOutcome CreateReplicationTask(const Model::CreateReplicationTaskRequest& request) const;
 
        template<typename CreateReplicationTaskRequestT = Model::CreateReplicationTaskRequest>
        Model::CreateReplicationTaskOutcomeCallable CreateReplicationTaskCallable(const CreateReplicationTaskRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::CreateReplicationTask, request);
        }
 
        template<typename CreateReplicationTaskRequestT = Model::CreateReplicationTaskRequest>
        void CreateReplicationTaskAsync(const CreateReplicationTaskRequestT& request, const CreateReplicationTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::CreateReplicationTask, request, handler, context);
        }
 
        virtual Model::DeleteCertificateOutcome DeleteCertificate(const Model::DeleteCertificateRequest& request) const;
 
        template<typename DeleteCertificateRequestT = Model::DeleteCertificateRequest>
        Model::DeleteCertificateOutcomeCallable DeleteCertificateCallable(const DeleteCertificateRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DeleteCertificate, request);
        }
 
        template<typename DeleteCertificateRequestT = Model::DeleteCertificateRequest>
        void DeleteCertificateAsync(const DeleteCertificateRequestT& request, const DeleteCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DeleteCertificate, request, handler, context);
        }
 
        virtual Model::DeleteConnectionOutcome DeleteConnection(const Model::DeleteConnectionRequest& request) const;
 
        template<typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
        Model::DeleteConnectionOutcomeCallable DeleteConnectionCallable(const DeleteConnectionRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DeleteConnection, request);
        }
 
        template<typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
        void DeleteConnectionAsync(const DeleteConnectionRequestT& request, const DeleteConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DeleteConnection, request, handler, context);
        }
 
        virtual Model::DeleteDataMigrationOutcome DeleteDataMigration(const Model::DeleteDataMigrationRequest& request) const;
 
        template<typename DeleteDataMigrationRequestT = Model::DeleteDataMigrationRequest>
        Model::DeleteDataMigrationOutcomeCallable DeleteDataMigrationCallable(const DeleteDataMigrationRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DeleteDataMigration, request);
        }
 
        template<typename DeleteDataMigrationRequestT = Model::DeleteDataMigrationRequest>
        void DeleteDataMigrationAsync(const DeleteDataMigrationRequestT& request, const DeleteDataMigrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DeleteDataMigration, request, handler, context);
        }
 
        virtual Model::DeleteDataProviderOutcome DeleteDataProvider(const Model::DeleteDataProviderRequest& request) const;
 
        template<typename DeleteDataProviderRequestT = Model::DeleteDataProviderRequest>
        Model::DeleteDataProviderOutcomeCallable DeleteDataProviderCallable(const DeleteDataProviderRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DeleteDataProvider, request);
        }
 
        template<typename DeleteDataProviderRequestT = Model::DeleteDataProviderRequest>
        void DeleteDataProviderAsync(const DeleteDataProviderRequestT& request, const DeleteDataProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DeleteDataProvider, request, handler, context);
        }
 
        virtual Model::DeleteEndpointOutcome DeleteEndpoint(const Model::DeleteEndpointRequest& request) const;
 
        template<typename DeleteEndpointRequestT = Model::DeleteEndpointRequest>
        Model::DeleteEndpointOutcomeCallable DeleteEndpointCallable(const DeleteEndpointRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DeleteEndpoint, request);
        }
 
        template<typename DeleteEndpointRequestT = Model::DeleteEndpointRequest>
        void DeleteEndpointAsync(const DeleteEndpointRequestT& request, const DeleteEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DeleteEndpoint, 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(&DatabaseMigrationServiceClient::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(&DatabaseMigrationServiceClient::DeleteEventSubscription, request, handler, context);
        }
 
        virtual Model::DeleteFleetAdvisorCollectorOutcome DeleteFleetAdvisorCollector(const Model::DeleteFleetAdvisorCollectorRequest& request) const;
 
        template<typename DeleteFleetAdvisorCollectorRequestT = Model::DeleteFleetAdvisorCollectorRequest>
        Model::DeleteFleetAdvisorCollectorOutcomeCallable DeleteFleetAdvisorCollectorCallable(const DeleteFleetAdvisorCollectorRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DeleteFleetAdvisorCollector, request);
        }
 
        template<typename DeleteFleetAdvisorCollectorRequestT = Model::DeleteFleetAdvisorCollectorRequest>
        void DeleteFleetAdvisorCollectorAsync(const DeleteFleetAdvisorCollectorRequestT& request, const DeleteFleetAdvisorCollectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DeleteFleetAdvisorCollector, request, handler, context);
        }
 
        virtual Model::DeleteFleetAdvisorDatabasesOutcome DeleteFleetAdvisorDatabases(const Model::DeleteFleetAdvisorDatabasesRequest& request) const;
 
        template<typename DeleteFleetAdvisorDatabasesRequestT = Model::DeleteFleetAdvisorDatabasesRequest>
        Model::DeleteFleetAdvisorDatabasesOutcomeCallable DeleteFleetAdvisorDatabasesCallable(const DeleteFleetAdvisorDatabasesRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DeleteFleetAdvisorDatabases, request);
        }
 
        template<typename DeleteFleetAdvisorDatabasesRequestT = Model::DeleteFleetAdvisorDatabasesRequest>
        void DeleteFleetAdvisorDatabasesAsync(const DeleteFleetAdvisorDatabasesRequestT& request, const DeleteFleetAdvisorDatabasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DeleteFleetAdvisorDatabases, request, handler, context);
        }
 
        virtual Model::DeleteInstanceProfileOutcome DeleteInstanceProfile(const Model::DeleteInstanceProfileRequest& request) const;
 
        template<typename DeleteInstanceProfileRequestT = Model::DeleteInstanceProfileRequest>
        Model::DeleteInstanceProfileOutcomeCallable DeleteInstanceProfileCallable(const DeleteInstanceProfileRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DeleteInstanceProfile, request);
        }
 
        template<typename DeleteInstanceProfileRequestT = Model::DeleteInstanceProfileRequest>
        void DeleteInstanceProfileAsync(const DeleteInstanceProfileRequestT& request, const DeleteInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DeleteInstanceProfile, request, handler, context);
        }
 
        virtual Model::DeleteMigrationProjectOutcome DeleteMigrationProject(const Model::DeleteMigrationProjectRequest& request) const;
 
        template<typename DeleteMigrationProjectRequestT = Model::DeleteMigrationProjectRequest>
        Model::DeleteMigrationProjectOutcomeCallable DeleteMigrationProjectCallable(const DeleteMigrationProjectRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DeleteMigrationProject, request);
        }
 
        template<typename DeleteMigrationProjectRequestT = Model::DeleteMigrationProjectRequest>
        void DeleteMigrationProjectAsync(const DeleteMigrationProjectRequestT& request, const DeleteMigrationProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DeleteMigrationProject, request, handler, context);
        }
 
        virtual Model::DeleteReplicationConfigOutcome DeleteReplicationConfig(const Model::DeleteReplicationConfigRequest& request) const;
 
        template<typename DeleteReplicationConfigRequestT = Model::DeleteReplicationConfigRequest>
        Model::DeleteReplicationConfigOutcomeCallable DeleteReplicationConfigCallable(const DeleteReplicationConfigRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DeleteReplicationConfig, request);
        }
 
        template<typename DeleteReplicationConfigRequestT = Model::DeleteReplicationConfigRequest>
        void DeleteReplicationConfigAsync(const DeleteReplicationConfigRequestT& request, const DeleteReplicationConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DeleteReplicationConfig, request, handler, context);
        }
 
        virtual Model::DeleteReplicationInstanceOutcome DeleteReplicationInstance(const Model::DeleteReplicationInstanceRequest& request) const;
 
        template<typename DeleteReplicationInstanceRequestT = Model::DeleteReplicationInstanceRequest>
        Model::DeleteReplicationInstanceOutcomeCallable DeleteReplicationInstanceCallable(const DeleteReplicationInstanceRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DeleteReplicationInstance, request);
        }
 
        template<typename DeleteReplicationInstanceRequestT = Model::DeleteReplicationInstanceRequest>
        void DeleteReplicationInstanceAsync(const DeleteReplicationInstanceRequestT& request, const DeleteReplicationInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DeleteReplicationInstance, request, handler, context);
        }
 
        virtual Model::DeleteReplicationSubnetGroupOutcome DeleteReplicationSubnetGroup(const Model::DeleteReplicationSubnetGroupRequest& request) const;
 
        template<typename DeleteReplicationSubnetGroupRequestT = Model::DeleteReplicationSubnetGroupRequest>
        Model::DeleteReplicationSubnetGroupOutcomeCallable DeleteReplicationSubnetGroupCallable(const DeleteReplicationSubnetGroupRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DeleteReplicationSubnetGroup, request);
        }
 
        template<typename DeleteReplicationSubnetGroupRequestT = Model::DeleteReplicationSubnetGroupRequest>
        void DeleteReplicationSubnetGroupAsync(const DeleteReplicationSubnetGroupRequestT& request, const DeleteReplicationSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DeleteReplicationSubnetGroup, request, handler, context);
        }
 
        virtual Model::DeleteReplicationTaskOutcome DeleteReplicationTask(const Model::DeleteReplicationTaskRequest& request) const;
 
        template<typename DeleteReplicationTaskRequestT = Model::DeleteReplicationTaskRequest>
        Model::DeleteReplicationTaskOutcomeCallable DeleteReplicationTaskCallable(const DeleteReplicationTaskRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DeleteReplicationTask, request);
        }
 
        template<typename DeleteReplicationTaskRequestT = Model::DeleteReplicationTaskRequest>
        void DeleteReplicationTaskAsync(const DeleteReplicationTaskRequestT& request, const DeleteReplicationTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DeleteReplicationTask, request, handler, context);
        }
 
        virtual Model::DeleteReplicationTaskAssessmentRunOutcome DeleteReplicationTaskAssessmentRun(const Model::DeleteReplicationTaskAssessmentRunRequest& request) const;
 
        template<typename DeleteReplicationTaskAssessmentRunRequestT = Model::DeleteReplicationTaskAssessmentRunRequest>
        Model::DeleteReplicationTaskAssessmentRunOutcomeCallable DeleteReplicationTaskAssessmentRunCallable(const DeleteReplicationTaskAssessmentRunRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DeleteReplicationTaskAssessmentRun, request);
        }
 
        template<typename DeleteReplicationTaskAssessmentRunRequestT = Model::DeleteReplicationTaskAssessmentRunRequest>
        void DeleteReplicationTaskAssessmentRunAsync(const DeleteReplicationTaskAssessmentRunRequestT& request, const DeleteReplicationTaskAssessmentRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DeleteReplicationTaskAssessmentRun, 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(&DatabaseMigrationServiceClient::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(&DatabaseMigrationServiceClient::DescribeAccountAttributes, request, handler, context);
        }
 
        virtual Model::DescribeApplicableIndividualAssessmentsOutcome DescribeApplicableIndividualAssessments(const Model::DescribeApplicableIndividualAssessmentsRequest& request = {}) const;
 
        template<typename DescribeApplicableIndividualAssessmentsRequestT = Model::DescribeApplicableIndividualAssessmentsRequest>
        Model::DescribeApplicableIndividualAssessmentsOutcomeCallable DescribeApplicableIndividualAssessmentsCallable(const DescribeApplicableIndividualAssessmentsRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeApplicableIndividualAssessments, request);
        }
 
        template<typename DescribeApplicableIndividualAssessmentsRequestT = Model::DescribeApplicableIndividualAssessmentsRequest>
        void DescribeApplicableIndividualAssessmentsAsync(const DescribeApplicableIndividualAssessmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeApplicableIndividualAssessmentsRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeApplicableIndividualAssessments, 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(&DatabaseMigrationServiceClient::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(&DatabaseMigrationServiceClient::DescribeCertificates, request, handler, context);
        }
 
        virtual Model::DescribeConnectionsOutcome DescribeConnections(const Model::DescribeConnectionsRequest& request = {}) const;
 
        template<typename DescribeConnectionsRequestT = Model::DescribeConnectionsRequest>
        Model::DescribeConnectionsOutcomeCallable DescribeConnectionsCallable(const DescribeConnectionsRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeConnections, request);
        }
 
        template<typename DescribeConnectionsRequestT = Model::DescribeConnectionsRequest>
        void DescribeConnectionsAsync(const DescribeConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeConnectionsRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeConnections, request, handler, context);
        }
 
        virtual Model::DescribeConversionConfigurationOutcome DescribeConversionConfiguration(const Model::DescribeConversionConfigurationRequest& request) const;
 
        template<typename DescribeConversionConfigurationRequestT = Model::DescribeConversionConfigurationRequest>
        Model::DescribeConversionConfigurationOutcomeCallable DescribeConversionConfigurationCallable(const DescribeConversionConfigurationRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeConversionConfiguration, request);
        }
 
        template<typename DescribeConversionConfigurationRequestT = Model::DescribeConversionConfigurationRequest>
        void DescribeConversionConfigurationAsync(const DescribeConversionConfigurationRequestT& request, const DescribeConversionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeConversionConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeDataMigrationsOutcome DescribeDataMigrations(const Model::DescribeDataMigrationsRequest& request = {}) const;
 
        template<typename DescribeDataMigrationsRequestT = Model::DescribeDataMigrationsRequest>
        Model::DescribeDataMigrationsOutcomeCallable DescribeDataMigrationsCallable(const DescribeDataMigrationsRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeDataMigrations, request);
        }
 
        template<typename DescribeDataMigrationsRequestT = Model::DescribeDataMigrationsRequest>
        void DescribeDataMigrationsAsync(const DescribeDataMigrationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDataMigrationsRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeDataMigrations, request, handler, context);
        }
 
        virtual Model::DescribeDataProvidersOutcome DescribeDataProviders(const Model::DescribeDataProvidersRequest& request = {}) const;
 
        template<typename DescribeDataProvidersRequestT = Model::DescribeDataProvidersRequest>
        Model::DescribeDataProvidersOutcomeCallable DescribeDataProvidersCallable(const DescribeDataProvidersRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeDataProviders, request);
        }
 
        template<typename DescribeDataProvidersRequestT = Model::DescribeDataProvidersRequest>
        void DescribeDataProvidersAsync(const DescribeDataProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDataProvidersRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeDataProviders, request, handler, context);
        }
 
        virtual Model::DescribeEndpointSettingsOutcome DescribeEndpointSettings(const Model::DescribeEndpointSettingsRequest& request) const;
 
        template<typename DescribeEndpointSettingsRequestT = Model::DescribeEndpointSettingsRequest>
        Model::DescribeEndpointSettingsOutcomeCallable DescribeEndpointSettingsCallable(const DescribeEndpointSettingsRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeEndpointSettings, request);
        }
 
        template<typename DescribeEndpointSettingsRequestT = Model::DescribeEndpointSettingsRequest>
        void DescribeEndpointSettingsAsync(const DescribeEndpointSettingsRequestT& request, const DescribeEndpointSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeEndpointSettings, request, handler, context);
        }
 
        virtual Model::DescribeEndpointTypesOutcome DescribeEndpointTypes(const Model::DescribeEndpointTypesRequest& request = {}) const;
 
        template<typename DescribeEndpointTypesRequestT = Model::DescribeEndpointTypesRequest>
        Model::DescribeEndpointTypesOutcomeCallable DescribeEndpointTypesCallable(const DescribeEndpointTypesRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeEndpointTypes, request);
        }
 
        template<typename DescribeEndpointTypesRequestT = Model::DescribeEndpointTypesRequest>
        void DescribeEndpointTypesAsync(const DescribeEndpointTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEndpointTypesRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeEndpointTypes, request, handler, context);
        }
 
        virtual Model::DescribeEndpointsOutcome DescribeEndpoints(const Model::DescribeEndpointsRequest& request = {}) const;
 
        template<typename DescribeEndpointsRequestT = Model::DescribeEndpointsRequest>
        Model::DescribeEndpointsOutcomeCallable DescribeEndpointsCallable(const DescribeEndpointsRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeEndpoints, request);
        }
 
        template<typename DescribeEndpointsRequestT = Model::DescribeEndpointsRequest>
        void DescribeEndpointsAsync(const DescribeEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEndpointsRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeEndpoints, request, handler, context);
        }
 
        virtual Model::DescribeEngineVersionsOutcome DescribeEngineVersions(const Model::DescribeEngineVersionsRequest& request = {}) const;
 
        template<typename DescribeEngineVersionsRequestT = Model::DescribeEngineVersionsRequest>
        Model::DescribeEngineVersionsOutcomeCallable DescribeEngineVersionsCallable(const DescribeEngineVersionsRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeEngineVersions, request);
        }
 
        template<typename DescribeEngineVersionsRequestT = Model::DescribeEngineVersionsRequest>
        void DescribeEngineVersionsAsync(const DescribeEngineVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEngineVersionsRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeEngineVersions, 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(&DatabaseMigrationServiceClient::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(&DatabaseMigrationServiceClient::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(&DatabaseMigrationServiceClient::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(&DatabaseMigrationServiceClient::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(&DatabaseMigrationServiceClient::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(&DatabaseMigrationServiceClient::DescribeEvents, request, handler, context);
        }
 
        virtual Model::DescribeExtensionPackAssociationsOutcome DescribeExtensionPackAssociations(const Model::DescribeExtensionPackAssociationsRequest& request) const;
 
        template<typename DescribeExtensionPackAssociationsRequestT = Model::DescribeExtensionPackAssociationsRequest>
        Model::DescribeExtensionPackAssociationsOutcomeCallable DescribeExtensionPackAssociationsCallable(const DescribeExtensionPackAssociationsRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeExtensionPackAssociations, request);
        }
 
        template<typename DescribeExtensionPackAssociationsRequestT = Model::DescribeExtensionPackAssociationsRequest>
        void DescribeExtensionPackAssociationsAsync(const DescribeExtensionPackAssociationsRequestT& request, const DescribeExtensionPackAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeExtensionPackAssociations, request, handler, context);
        }
 
        virtual Model::DescribeFleetAdvisorCollectorsOutcome DescribeFleetAdvisorCollectors(const Model::DescribeFleetAdvisorCollectorsRequest& request = {}) const;
 
        template<typename DescribeFleetAdvisorCollectorsRequestT = Model::DescribeFleetAdvisorCollectorsRequest>
        Model::DescribeFleetAdvisorCollectorsOutcomeCallable DescribeFleetAdvisorCollectorsCallable(const DescribeFleetAdvisorCollectorsRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeFleetAdvisorCollectors, request);
        }
 
        template<typename DescribeFleetAdvisorCollectorsRequestT = Model::DescribeFleetAdvisorCollectorsRequest>
        void DescribeFleetAdvisorCollectorsAsync(const DescribeFleetAdvisorCollectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeFleetAdvisorCollectorsRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeFleetAdvisorCollectors, request, handler, context);
        }
 
        virtual Model::DescribeFleetAdvisorDatabasesOutcome DescribeFleetAdvisorDatabases(const Model::DescribeFleetAdvisorDatabasesRequest& request = {}) const;
 
        template<typename DescribeFleetAdvisorDatabasesRequestT = Model::DescribeFleetAdvisorDatabasesRequest>
        Model::DescribeFleetAdvisorDatabasesOutcomeCallable DescribeFleetAdvisorDatabasesCallable(const DescribeFleetAdvisorDatabasesRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeFleetAdvisorDatabases, request);
        }
 
        template<typename DescribeFleetAdvisorDatabasesRequestT = Model::DescribeFleetAdvisorDatabasesRequest>
        void DescribeFleetAdvisorDatabasesAsync(const DescribeFleetAdvisorDatabasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeFleetAdvisorDatabasesRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeFleetAdvisorDatabases, request, handler, context);
        }
 
        virtual Model::DescribeFleetAdvisorLsaAnalysisOutcome DescribeFleetAdvisorLsaAnalysis(const Model::DescribeFleetAdvisorLsaAnalysisRequest& request = {}) const;
 
        template<typename DescribeFleetAdvisorLsaAnalysisRequestT = Model::DescribeFleetAdvisorLsaAnalysisRequest>
        Model::DescribeFleetAdvisorLsaAnalysisOutcomeCallable DescribeFleetAdvisorLsaAnalysisCallable(const DescribeFleetAdvisorLsaAnalysisRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeFleetAdvisorLsaAnalysis, request);
        }
 
        template<typename DescribeFleetAdvisorLsaAnalysisRequestT = Model::DescribeFleetAdvisorLsaAnalysisRequest>
        void DescribeFleetAdvisorLsaAnalysisAsync(const DescribeFleetAdvisorLsaAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeFleetAdvisorLsaAnalysisRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeFleetAdvisorLsaAnalysis, request, handler, context);
        }
 
        virtual Model::DescribeFleetAdvisorSchemaObjectSummaryOutcome DescribeFleetAdvisorSchemaObjectSummary(const Model::DescribeFleetAdvisorSchemaObjectSummaryRequest& request = {}) const;
 
        template<typename DescribeFleetAdvisorSchemaObjectSummaryRequestT = Model::DescribeFleetAdvisorSchemaObjectSummaryRequest>
        Model::DescribeFleetAdvisorSchemaObjectSummaryOutcomeCallable DescribeFleetAdvisorSchemaObjectSummaryCallable(const DescribeFleetAdvisorSchemaObjectSummaryRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeFleetAdvisorSchemaObjectSummary, request);
        }
 
        template<typename DescribeFleetAdvisorSchemaObjectSummaryRequestT = Model::DescribeFleetAdvisorSchemaObjectSummaryRequest>
        void DescribeFleetAdvisorSchemaObjectSummaryAsync(const DescribeFleetAdvisorSchemaObjectSummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeFleetAdvisorSchemaObjectSummaryRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeFleetAdvisorSchemaObjectSummary, request, handler, context);
        }
 
        virtual Model::DescribeFleetAdvisorSchemasOutcome DescribeFleetAdvisorSchemas(const Model::DescribeFleetAdvisorSchemasRequest& request = {}) const;
 
        template<typename DescribeFleetAdvisorSchemasRequestT = Model::DescribeFleetAdvisorSchemasRequest>
        Model::DescribeFleetAdvisorSchemasOutcomeCallable DescribeFleetAdvisorSchemasCallable(const DescribeFleetAdvisorSchemasRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeFleetAdvisorSchemas, request);
        }
 
        template<typename DescribeFleetAdvisorSchemasRequestT = Model::DescribeFleetAdvisorSchemasRequest>
        void DescribeFleetAdvisorSchemasAsync(const DescribeFleetAdvisorSchemasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeFleetAdvisorSchemasRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeFleetAdvisorSchemas, request, handler, context);
        }
 
        virtual Model::DescribeInstanceProfilesOutcome DescribeInstanceProfiles(const Model::DescribeInstanceProfilesRequest& request = {}) const;
 
        template<typename DescribeInstanceProfilesRequestT = Model::DescribeInstanceProfilesRequest>
        Model::DescribeInstanceProfilesOutcomeCallable DescribeInstanceProfilesCallable(const DescribeInstanceProfilesRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeInstanceProfiles, request);
        }
 
        template<typename DescribeInstanceProfilesRequestT = Model::DescribeInstanceProfilesRequest>
        void DescribeInstanceProfilesAsync(const DescribeInstanceProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeInstanceProfilesRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeInstanceProfiles, request, handler, context);
        }
 
        virtual Model::DescribeMetadataModelAssessmentsOutcome DescribeMetadataModelAssessments(const Model::DescribeMetadataModelAssessmentsRequest& request) const;
 
        template<typename DescribeMetadataModelAssessmentsRequestT = Model::DescribeMetadataModelAssessmentsRequest>
        Model::DescribeMetadataModelAssessmentsOutcomeCallable DescribeMetadataModelAssessmentsCallable(const DescribeMetadataModelAssessmentsRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeMetadataModelAssessments, request);
        }
 
        template<typename DescribeMetadataModelAssessmentsRequestT = Model::DescribeMetadataModelAssessmentsRequest>
        void DescribeMetadataModelAssessmentsAsync(const DescribeMetadataModelAssessmentsRequestT& request, const DescribeMetadataModelAssessmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeMetadataModelAssessments, request, handler, context);
        }
 
        virtual Model::DescribeMetadataModelConversionsOutcome DescribeMetadataModelConversions(const Model::DescribeMetadataModelConversionsRequest& request) const;
 
        template<typename DescribeMetadataModelConversionsRequestT = Model::DescribeMetadataModelConversionsRequest>
        Model::DescribeMetadataModelConversionsOutcomeCallable DescribeMetadataModelConversionsCallable(const DescribeMetadataModelConversionsRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeMetadataModelConversions, request);
        }
 
        template<typename DescribeMetadataModelConversionsRequestT = Model::DescribeMetadataModelConversionsRequest>
        void DescribeMetadataModelConversionsAsync(const DescribeMetadataModelConversionsRequestT& request, const DescribeMetadataModelConversionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeMetadataModelConversions, request, handler, context);
        }
 
        virtual Model::DescribeMetadataModelExportsAsScriptOutcome DescribeMetadataModelExportsAsScript(const Model::DescribeMetadataModelExportsAsScriptRequest& request) const;
 
        template<typename DescribeMetadataModelExportsAsScriptRequestT = Model::DescribeMetadataModelExportsAsScriptRequest>
        Model::DescribeMetadataModelExportsAsScriptOutcomeCallable DescribeMetadataModelExportsAsScriptCallable(const DescribeMetadataModelExportsAsScriptRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeMetadataModelExportsAsScript, request);
        }
 
        template<typename DescribeMetadataModelExportsAsScriptRequestT = Model::DescribeMetadataModelExportsAsScriptRequest>
        void DescribeMetadataModelExportsAsScriptAsync(const DescribeMetadataModelExportsAsScriptRequestT& request, const DescribeMetadataModelExportsAsScriptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeMetadataModelExportsAsScript, request, handler, context);
        }
 
        virtual Model::DescribeMetadataModelExportsToTargetOutcome DescribeMetadataModelExportsToTarget(const Model::DescribeMetadataModelExportsToTargetRequest& request) const;
 
        template<typename DescribeMetadataModelExportsToTargetRequestT = Model::DescribeMetadataModelExportsToTargetRequest>
        Model::DescribeMetadataModelExportsToTargetOutcomeCallable DescribeMetadataModelExportsToTargetCallable(const DescribeMetadataModelExportsToTargetRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeMetadataModelExportsToTarget, request);
        }
 
        template<typename DescribeMetadataModelExportsToTargetRequestT = Model::DescribeMetadataModelExportsToTargetRequest>
        void DescribeMetadataModelExportsToTargetAsync(const DescribeMetadataModelExportsToTargetRequestT& request, const DescribeMetadataModelExportsToTargetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeMetadataModelExportsToTarget, request, handler, context);
        }
 
        virtual Model::DescribeMetadataModelImportsOutcome DescribeMetadataModelImports(const Model::DescribeMetadataModelImportsRequest& request) const;
 
        template<typename DescribeMetadataModelImportsRequestT = Model::DescribeMetadataModelImportsRequest>
        Model::DescribeMetadataModelImportsOutcomeCallable DescribeMetadataModelImportsCallable(const DescribeMetadataModelImportsRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeMetadataModelImports, request);
        }
 
        template<typename DescribeMetadataModelImportsRequestT = Model::DescribeMetadataModelImportsRequest>
        void DescribeMetadataModelImportsAsync(const DescribeMetadataModelImportsRequestT& request, const DescribeMetadataModelImportsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeMetadataModelImports, request, handler, context);
        }
 
        virtual Model::DescribeMigrationProjectsOutcome DescribeMigrationProjects(const Model::DescribeMigrationProjectsRequest& request = {}) const;
 
        template<typename DescribeMigrationProjectsRequestT = Model::DescribeMigrationProjectsRequest>
        Model::DescribeMigrationProjectsOutcomeCallable DescribeMigrationProjectsCallable(const DescribeMigrationProjectsRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeMigrationProjects, request);
        }
 
        template<typename DescribeMigrationProjectsRequestT = Model::DescribeMigrationProjectsRequest>
        void DescribeMigrationProjectsAsync(const DescribeMigrationProjectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeMigrationProjectsRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeMigrationProjects, request, handler, context);
        }
 
        virtual Model::DescribeOrderableReplicationInstancesOutcome DescribeOrderableReplicationInstances(const Model::DescribeOrderableReplicationInstancesRequest& request = {}) const;
 
        template<typename DescribeOrderableReplicationInstancesRequestT = Model::DescribeOrderableReplicationInstancesRequest>
        Model::DescribeOrderableReplicationInstancesOutcomeCallable DescribeOrderableReplicationInstancesCallable(const DescribeOrderableReplicationInstancesRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeOrderableReplicationInstances, request);
        }
 
        template<typename DescribeOrderableReplicationInstancesRequestT = Model::DescribeOrderableReplicationInstancesRequest>
        void DescribeOrderableReplicationInstancesAsync(const DescribeOrderableReplicationInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeOrderableReplicationInstancesRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeOrderableReplicationInstances, 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(&DatabaseMigrationServiceClient::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(&DatabaseMigrationServiceClient::DescribePendingMaintenanceActions, request, handler, context);
        }
 
        virtual Model::DescribeRecommendationLimitationsOutcome DescribeRecommendationLimitations(const Model::DescribeRecommendationLimitationsRequest& request = {}) const;
 
        template<typename DescribeRecommendationLimitationsRequestT = Model::DescribeRecommendationLimitationsRequest>
        Model::DescribeRecommendationLimitationsOutcomeCallable DescribeRecommendationLimitationsCallable(const DescribeRecommendationLimitationsRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeRecommendationLimitations, request);
        }
 
        template<typename DescribeRecommendationLimitationsRequestT = Model::DescribeRecommendationLimitationsRequest>
        void DescribeRecommendationLimitationsAsync(const DescribeRecommendationLimitationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeRecommendationLimitationsRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeRecommendationLimitations, request, handler, context);
        }
 
        virtual Model::DescribeRecommendationsOutcome DescribeRecommendations(const Model::DescribeRecommendationsRequest& request = {}) const;
 
        template<typename DescribeRecommendationsRequestT = Model::DescribeRecommendationsRequest>
        Model::DescribeRecommendationsOutcomeCallable DescribeRecommendationsCallable(const DescribeRecommendationsRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeRecommendations, request);
        }
 
        template<typename DescribeRecommendationsRequestT = Model::DescribeRecommendationsRequest>
        void DescribeRecommendationsAsync(const DescribeRecommendationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeRecommendationsRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeRecommendations, request, handler, context);
        }
 
        virtual Model::DescribeRefreshSchemasStatusOutcome DescribeRefreshSchemasStatus(const Model::DescribeRefreshSchemasStatusRequest& request) const;
 
        template<typename DescribeRefreshSchemasStatusRequestT = Model::DescribeRefreshSchemasStatusRequest>
        Model::DescribeRefreshSchemasStatusOutcomeCallable DescribeRefreshSchemasStatusCallable(const DescribeRefreshSchemasStatusRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeRefreshSchemasStatus, request);
        }
 
        template<typename DescribeRefreshSchemasStatusRequestT = Model::DescribeRefreshSchemasStatusRequest>
        void DescribeRefreshSchemasStatusAsync(const DescribeRefreshSchemasStatusRequestT& request, const DescribeRefreshSchemasStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeRefreshSchemasStatus, request, handler, context);
        }
 
        virtual Model::DescribeReplicationConfigsOutcome DescribeReplicationConfigs(const Model::DescribeReplicationConfigsRequest& request = {}) const;
 
        template<typename DescribeReplicationConfigsRequestT = Model::DescribeReplicationConfigsRequest>
        Model::DescribeReplicationConfigsOutcomeCallable DescribeReplicationConfigsCallable(const DescribeReplicationConfigsRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeReplicationConfigs, request);
        }
 
        template<typename DescribeReplicationConfigsRequestT = Model::DescribeReplicationConfigsRequest>
        void DescribeReplicationConfigsAsync(const DescribeReplicationConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReplicationConfigsRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeReplicationConfigs, request, handler, context);
        }
 
        virtual Model::DescribeReplicationInstanceTaskLogsOutcome DescribeReplicationInstanceTaskLogs(const Model::DescribeReplicationInstanceTaskLogsRequest& request) const;
 
        template<typename DescribeReplicationInstanceTaskLogsRequestT = Model::DescribeReplicationInstanceTaskLogsRequest>
        Model::DescribeReplicationInstanceTaskLogsOutcomeCallable DescribeReplicationInstanceTaskLogsCallable(const DescribeReplicationInstanceTaskLogsRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeReplicationInstanceTaskLogs, request);
        }
 
        template<typename DescribeReplicationInstanceTaskLogsRequestT = Model::DescribeReplicationInstanceTaskLogsRequest>
        void DescribeReplicationInstanceTaskLogsAsync(const DescribeReplicationInstanceTaskLogsRequestT& request, const DescribeReplicationInstanceTaskLogsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeReplicationInstanceTaskLogs, request, handler, context);
        }
 
        virtual Model::DescribeReplicationInstancesOutcome DescribeReplicationInstances(const Model::DescribeReplicationInstancesRequest& request = {}) const;
 
        template<typename DescribeReplicationInstancesRequestT = Model::DescribeReplicationInstancesRequest>
        Model::DescribeReplicationInstancesOutcomeCallable DescribeReplicationInstancesCallable(const DescribeReplicationInstancesRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeReplicationInstances, request);
        }
 
        template<typename DescribeReplicationInstancesRequestT = Model::DescribeReplicationInstancesRequest>
        void DescribeReplicationInstancesAsync(const DescribeReplicationInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReplicationInstancesRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeReplicationInstances, request, handler, context);
        }
 
        virtual Model::DescribeReplicationSubnetGroupsOutcome DescribeReplicationSubnetGroups(const Model::DescribeReplicationSubnetGroupsRequest& request = {}) const;
 
        template<typename DescribeReplicationSubnetGroupsRequestT = Model::DescribeReplicationSubnetGroupsRequest>
        Model::DescribeReplicationSubnetGroupsOutcomeCallable DescribeReplicationSubnetGroupsCallable(const DescribeReplicationSubnetGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeReplicationSubnetGroups, request);
        }
 
        template<typename DescribeReplicationSubnetGroupsRequestT = Model::DescribeReplicationSubnetGroupsRequest>
        void DescribeReplicationSubnetGroupsAsync(const DescribeReplicationSubnetGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReplicationSubnetGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeReplicationSubnetGroups, request, handler, context);
        }
 
        virtual Model::DescribeReplicationTableStatisticsOutcome DescribeReplicationTableStatistics(const Model::DescribeReplicationTableStatisticsRequest& request) const;
 
        template<typename DescribeReplicationTableStatisticsRequestT = Model::DescribeReplicationTableStatisticsRequest>
        Model::DescribeReplicationTableStatisticsOutcomeCallable DescribeReplicationTableStatisticsCallable(const DescribeReplicationTableStatisticsRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeReplicationTableStatistics, request);
        }
 
        template<typename DescribeReplicationTableStatisticsRequestT = Model::DescribeReplicationTableStatisticsRequest>
        void DescribeReplicationTableStatisticsAsync(const DescribeReplicationTableStatisticsRequestT& request, const DescribeReplicationTableStatisticsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeReplicationTableStatistics, request, handler, context);
        }
 
        virtual Model::DescribeReplicationTaskAssessmentResultsOutcome DescribeReplicationTaskAssessmentResults(const Model::DescribeReplicationTaskAssessmentResultsRequest& request = {}) const;
 
        template<typename DescribeReplicationTaskAssessmentResultsRequestT = Model::DescribeReplicationTaskAssessmentResultsRequest>
        Model::DescribeReplicationTaskAssessmentResultsOutcomeCallable DescribeReplicationTaskAssessmentResultsCallable(const DescribeReplicationTaskAssessmentResultsRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeReplicationTaskAssessmentResults, request);
        }
 
        template<typename DescribeReplicationTaskAssessmentResultsRequestT = Model::DescribeReplicationTaskAssessmentResultsRequest>
        void DescribeReplicationTaskAssessmentResultsAsync(const DescribeReplicationTaskAssessmentResultsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReplicationTaskAssessmentResultsRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeReplicationTaskAssessmentResults, request, handler, context);
        }
 
        virtual Model::DescribeReplicationTaskAssessmentRunsOutcome DescribeReplicationTaskAssessmentRuns(const Model::DescribeReplicationTaskAssessmentRunsRequest& request = {}) const;
 
        template<typename DescribeReplicationTaskAssessmentRunsRequestT = Model::DescribeReplicationTaskAssessmentRunsRequest>
        Model::DescribeReplicationTaskAssessmentRunsOutcomeCallable DescribeReplicationTaskAssessmentRunsCallable(const DescribeReplicationTaskAssessmentRunsRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeReplicationTaskAssessmentRuns, request);
        }
 
        template<typename DescribeReplicationTaskAssessmentRunsRequestT = Model::DescribeReplicationTaskAssessmentRunsRequest>
        void DescribeReplicationTaskAssessmentRunsAsync(const DescribeReplicationTaskAssessmentRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReplicationTaskAssessmentRunsRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeReplicationTaskAssessmentRuns, request, handler, context);
        }
 
        virtual Model::DescribeReplicationTaskIndividualAssessmentsOutcome DescribeReplicationTaskIndividualAssessments(const Model::DescribeReplicationTaskIndividualAssessmentsRequest& request = {}) const;
 
        template<typename DescribeReplicationTaskIndividualAssessmentsRequestT = Model::DescribeReplicationTaskIndividualAssessmentsRequest>
        Model::DescribeReplicationTaskIndividualAssessmentsOutcomeCallable DescribeReplicationTaskIndividualAssessmentsCallable(const DescribeReplicationTaskIndividualAssessmentsRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeReplicationTaskIndividualAssessments, request);
        }
 
        template<typename DescribeReplicationTaskIndividualAssessmentsRequestT = Model::DescribeReplicationTaskIndividualAssessmentsRequest>
        void DescribeReplicationTaskIndividualAssessmentsAsync(const DescribeReplicationTaskIndividualAssessmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReplicationTaskIndividualAssessmentsRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeReplicationTaskIndividualAssessments, request, handler, context);
        }
 
        virtual Model::DescribeReplicationTasksOutcome DescribeReplicationTasks(const Model::DescribeReplicationTasksRequest& request = {}) const;
 
        template<typename DescribeReplicationTasksRequestT = Model::DescribeReplicationTasksRequest>
        Model::DescribeReplicationTasksOutcomeCallable DescribeReplicationTasksCallable(const DescribeReplicationTasksRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeReplicationTasks, request);
        }
 
        template<typename DescribeReplicationTasksRequestT = Model::DescribeReplicationTasksRequest>
        void DescribeReplicationTasksAsync(const DescribeReplicationTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReplicationTasksRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeReplicationTasks, request, handler, context);
        }
 
        virtual Model::DescribeReplicationsOutcome DescribeReplications(const Model::DescribeReplicationsRequest& request = {}) const;
 
        template<typename DescribeReplicationsRequestT = Model::DescribeReplicationsRequest>
        Model::DescribeReplicationsOutcomeCallable DescribeReplicationsCallable(const DescribeReplicationsRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeReplications, request);
        }
 
        template<typename DescribeReplicationsRequestT = Model::DescribeReplicationsRequest>
        void DescribeReplicationsAsync(const DescribeReplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReplicationsRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeReplications, request, handler, context);
        }
 
        virtual Model::DescribeSchemasOutcome DescribeSchemas(const Model::DescribeSchemasRequest& request) const;
 
        template<typename DescribeSchemasRequestT = Model::DescribeSchemasRequest>
        Model::DescribeSchemasOutcomeCallable DescribeSchemasCallable(const DescribeSchemasRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeSchemas, request);
        }
 
        template<typename DescribeSchemasRequestT = Model::DescribeSchemasRequest>
        void DescribeSchemasAsync(const DescribeSchemasRequestT& request, const DescribeSchemasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeSchemas, request, handler, context);
        }
 
        virtual Model::DescribeTableStatisticsOutcome DescribeTableStatistics(const Model::DescribeTableStatisticsRequest& request) const;
 
        template<typename DescribeTableStatisticsRequestT = Model::DescribeTableStatisticsRequest>
        Model::DescribeTableStatisticsOutcomeCallable DescribeTableStatisticsCallable(const DescribeTableStatisticsRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::DescribeTableStatistics, request);
        }
 
        template<typename DescribeTableStatisticsRequestT = Model::DescribeTableStatisticsRequest>
        void DescribeTableStatisticsAsync(const DescribeTableStatisticsRequestT& request, const DescribeTableStatisticsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::DescribeTableStatistics, request, handler, context);
        }
 
        virtual Model::ExportMetadataModelAssessmentOutcome ExportMetadataModelAssessment(const Model::ExportMetadataModelAssessmentRequest& request) const;
 
        template<typename ExportMetadataModelAssessmentRequestT = Model::ExportMetadataModelAssessmentRequest>
        Model::ExportMetadataModelAssessmentOutcomeCallable ExportMetadataModelAssessmentCallable(const ExportMetadataModelAssessmentRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::ExportMetadataModelAssessment, request);
        }
 
        template<typename ExportMetadataModelAssessmentRequestT = Model::ExportMetadataModelAssessmentRequest>
        void ExportMetadataModelAssessmentAsync(const ExportMetadataModelAssessmentRequestT& request, const ExportMetadataModelAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::ExportMetadataModelAssessment, request, handler, context);
        }
 
        virtual Model::ImportCertificateOutcome ImportCertificate(const Model::ImportCertificateRequest& request) const;
 
        template<typename ImportCertificateRequestT = Model::ImportCertificateRequest>
        Model::ImportCertificateOutcomeCallable ImportCertificateCallable(const ImportCertificateRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::ImportCertificate, request);
        }
 
        template<typename ImportCertificateRequestT = Model::ImportCertificateRequest>
        void ImportCertificateAsync(const ImportCertificateRequestT& request, const ImportCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::ImportCertificate, 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(&DatabaseMigrationServiceClient::ListTagsForResource, request);
        }
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        void ListTagsForResourceAsync(const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTagsForResourceRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ModifyConversionConfigurationOutcome ModifyConversionConfiguration(const Model::ModifyConversionConfigurationRequest& request) const;
 
        template<typename ModifyConversionConfigurationRequestT = Model::ModifyConversionConfigurationRequest>
        Model::ModifyConversionConfigurationOutcomeCallable ModifyConversionConfigurationCallable(const ModifyConversionConfigurationRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::ModifyConversionConfiguration, request);
        }
 
        template<typename ModifyConversionConfigurationRequestT = Model::ModifyConversionConfigurationRequest>
        void ModifyConversionConfigurationAsync(const ModifyConversionConfigurationRequestT& request, const ModifyConversionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::ModifyConversionConfiguration, request, handler, context);
        }
 
        virtual Model::ModifyDataMigrationOutcome ModifyDataMigration(const Model::ModifyDataMigrationRequest& request) const;
 
        template<typename ModifyDataMigrationRequestT = Model::ModifyDataMigrationRequest>
        Model::ModifyDataMigrationOutcomeCallable ModifyDataMigrationCallable(const ModifyDataMigrationRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::ModifyDataMigration, request);
        }
 
        template<typename ModifyDataMigrationRequestT = Model::ModifyDataMigrationRequest>
        void ModifyDataMigrationAsync(const ModifyDataMigrationRequestT& request, const ModifyDataMigrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::ModifyDataMigration, request, handler, context);
        }
 
        virtual Model::ModifyDataProviderOutcome ModifyDataProvider(const Model::ModifyDataProviderRequest& request) const;
 
        template<typename ModifyDataProviderRequestT = Model::ModifyDataProviderRequest>
        Model::ModifyDataProviderOutcomeCallable ModifyDataProviderCallable(const ModifyDataProviderRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::ModifyDataProvider, request);
        }
 
        template<typename ModifyDataProviderRequestT = Model::ModifyDataProviderRequest>
        void ModifyDataProviderAsync(const ModifyDataProviderRequestT& request, const ModifyDataProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::ModifyDataProvider, request, handler, context);
        }
 
        virtual Model::ModifyEndpointOutcome ModifyEndpoint(const Model::ModifyEndpointRequest& request) const;
 
        template<typename ModifyEndpointRequestT = Model::ModifyEndpointRequest>
        Model::ModifyEndpointOutcomeCallable ModifyEndpointCallable(const ModifyEndpointRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::ModifyEndpoint, request);
        }
 
        template<typename ModifyEndpointRequestT = Model::ModifyEndpointRequest>
        void ModifyEndpointAsync(const ModifyEndpointRequestT& request, const ModifyEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::ModifyEndpoint, 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(&DatabaseMigrationServiceClient::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(&DatabaseMigrationServiceClient::ModifyEventSubscription, request, handler, context);
        }
 
        virtual Model::ModifyInstanceProfileOutcome ModifyInstanceProfile(const Model::ModifyInstanceProfileRequest& request) const;
 
        template<typename ModifyInstanceProfileRequestT = Model::ModifyInstanceProfileRequest>
        Model::ModifyInstanceProfileOutcomeCallable ModifyInstanceProfileCallable(const ModifyInstanceProfileRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::ModifyInstanceProfile, request);
        }
 
        template<typename ModifyInstanceProfileRequestT = Model::ModifyInstanceProfileRequest>
        void ModifyInstanceProfileAsync(const ModifyInstanceProfileRequestT& request, const ModifyInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::ModifyInstanceProfile, request, handler, context);
        }
 
        virtual Model::ModifyMigrationProjectOutcome ModifyMigrationProject(const Model::ModifyMigrationProjectRequest& request) const;
 
        template<typename ModifyMigrationProjectRequestT = Model::ModifyMigrationProjectRequest>
        Model::ModifyMigrationProjectOutcomeCallable ModifyMigrationProjectCallable(const ModifyMigrationProjectRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::ModifyMigrationProject, request);
        }
 
        template<typename ModifyMigrationProjectRequestT = Model::ModifyMigrationProjectRequest>
        void ModifyMigrationProjectAsync(const ModifyMigrationProjectRequestT& request, const ModifyMigrationProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::ModifyMigrationProject, request, handler, context);
        }
 
        virtual Model::ModifyReplicationConfigOutcome ModifyReplicationConfig(const Model::ModifyReplicationConfigRequest& request) const;
 
        template<typename ModifyReplicationConfigRequestT = Model::ModifyReplicationConfigRequest>
        Model::ModifyReplicationConfigOutcomeCallable ModifyReplicationConfigCallable(const ModifyReplicationConfigRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::ModifyReplicationConfig, request);
        }
 
        template<typename ModifyReplicationConfigRequestT = Model::ModifyReplicationConfigRequest>
        void ModifyReplicationConfigAsync(const ModifyReplicationConfigRequestT& request, const ModifyReplicationConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::ModifyReplicationConfig, request, handler, context);
        }
 
        virtual Model::ModifyReplicationInstanceOutcome ModifyReplicationInstance(const Model::ModifyReplicationInstanceRequest& request) const;
 
        template<typename ModifyReplicationInstanceRequestT = Model::ModifyReplicationInstanceRequest>
        Model::ModifyReplicationInstanceOutcomeCallable ModifyReplicationInstanceCallable(const ModifyReplicationInstanceRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::ModifyReplicationInstance, request);
        }
 
        template<typename ModifyReplicationInstanceRequestT = Model::ModifyReplicationInstanceRequest>
        void ModifyReplicationInstanceAsync(const ModifyReplicationInstanceRequestT& request, const ModifyReplicationInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::ModifyReplicationInstance, request, handler, context);
        }
 
        virtual Model::ModifyReplicationSubnetGroupOutcome ModifyReplicationSubnetGroup(const Model::ModifyReplicationSubnetGroupRequest& request) const;
 
        template<typename ModifyReplicationSubnetGroupRequestT = Model::ModifyReplicationSubnetGroupRequest>
        Model::ModifyReplicationSubnetGroupOutcomeCallable ModifyReplicationSubnetGroupCallable(const ModifyReplicationSubnetGroupRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::ModifyReplicationSubnetGroup, request);
        }
 
        template<typename ModifyReplicationSubnetGroupRequestT = Model::ModifyReplicationSubnetGroupRequest>
        void ModifyReplicationSubnetGroupAsync(const ModifyReplicationSubnetGroupRequestT& request, const ModifyReplicationSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::ModifyReplicationSubnetGroup, request, handler, context);
        }
 
        virtual Model::ModifyReplicationTaskOutcome ModifyReplicationTask(const Model::ModifyReplicationTaskRequest& request) const;
 
        template<typename ModifyReplicationTaskRequestT = Model::ModifyReplicationTaskRequest>
        Model::ModifyReplicationTaskOutcomeCallable ModifyReplicationTaskCallable(const ModifyReplicationTaskRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::ModifyReplicationTask, request);
        }
 
        template<typename ModifyReplicationTaskRequestT = Model::ModifyReplicationTaskRequest>
        void ModifyReplicationTaskAsync(const ModifyReplicationTaskRequestT& request, const ModifyReplicationTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::ModifyReplicationTask, request, handler, context);
        }
 
        virtual Model::MoveReplicationTaskOutcome MoveReplicationTask(const Model::MoveReplicationTaskRequest& request) const;
 
        template<typename MoveReplicationTaskRequestT = Model::MoveReplicationTaskRequest>
        Model::MoveReplicationTaskOutcomeCallable MoveReplicationTaskCallable(const MoveReplicationTaskRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::MoveReplicationTask, request);
        }
 
        template<typename MoveReplicationTaskRequestT = Model::MoveReplicationTaskRequest>
        void MoveReplicationTaskAsync(const MoveReplicationTaskRequestT& request, const MoveReplicationTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::MoveReplicationTask, request, handler, context);
        }
 
        virtual Model::RebootReplicationInstanceOutcome RebootReplicationInstance(const Model::RebootReplicationInstanceRequest& request) const;
 
        template<typename RebootReplicationInstanceRequestT = Model::RebootReplicationInstanceRequest>
        Model::RebootReplicationInstanceOutcomeCallable RebootReplicationInstanceCallable(const RebootReplicationInstanceRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::RebootReplicationInstance, request);
        }
 
        template<typename RebootReplicationInstanceRequestT = Model::RebootReplicationInstanceRequest>
        void RebootReplicationInstanceAsync(const RebootReplicationInstanceRequestT& request, const RebootReplicationInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::RebootReplicationInstance, request, handler, context);
        }
 
        virtual Model::RefreshSchemasOutcome RefreshSchemas(const Model::RefreshSchemasRequest& request) const;
 
        template<typename RefreshSchemasRequestT = Model::RefreshSchemasRequest>
        Model::RefreshSchemasOutcomeCallable RefreshSchemasCallable(const RefreshSchemasRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::RefreshSchemas, request);
        }
 
        template<typename RefreshSchemasRequestT = Model::RefreshSchemasRequest>
        void RefreshSchemasAsync(const RefreshSchemasRequestT& request, const RefreshSchemasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::RefreshSchemas, request, handler, context);
        }
 
        virtual Model::ReloadReplicationTablesOutcome ReloadReplicationTables(const Model::ReloadReplicationTablesRequest& request) const;
 
        template<typename ReloadReplicationTablesRequestT = Model::ReloadReplicationTablesRequest>
        Model::ReloadReplicationTablesOutcomeCallable ReloadReplicationTablesCallable(const ReloadReplicationTablesRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::ReloadReplicationTables, request);
        }
 
        template<typename ReloadReplicationTablesRequestT = Model::ReloadReplicationTablesRequest>
        void ReloadReplicationTablesAsync(const ReloadReplicationTablesRequestT& request, const ReloadReplicationTablesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::ReloadReplicationTables, request, handler, context);
        }
 
        virtual Model::ReloadTablesOutcome ReloadTables(const Model::ReloadTablesRequest& request) const;
 
        template<typename ReloadTablesRequestT = Model::ReloadTablesRequest>
        Model::ReloadTablesOutcomeCallable ReloadTablesCallable(const ReloadTablesRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::ReloadTables, request);
        }
 
        template<typename ReloadTablesRequestT = Model::ReloadTablesRequest>
        void ReloadTablesAsync(const ReloadTablesRequestT& request, const ReloadTablesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::ReloadTables, 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(&DatabaseMigrationServiceClient::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(&DatabaseMigrationServiceClient::RemoveTagsFromResource, request, handler, context);
        }
 
        virtual Model::RunFleetAdvisorLsaAnalysisOutcome RunFleetAdvisorLsaAnalysis(const Model::RunFleetAdvisorLsaAnalysisRequest& request = {}) const;
 
        template<typename RunFleetAdvisorLsaAnalysisRequestT = Model::RunFleetAdvisorLsaAnalysisRequest>
        Model::RunFleetAdvisorLsaAnalysisOutcomeCallable RunFleetAdvisorLsaAnalysisCallable(const RunFleetAdvisorLsaAnalysisRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::RunFleetAdvisorLsaAnalysis, request);
        }
 
        template<typename RunFleetAdvisorLsaAnalysisRequestT = Model::RunFleetAdvisorLsaAnalysisRequest>
        void RunFleetAdvisorLsaAnalysisAsync(const RunFleetAdvisorLsaAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const RunFleetAdvisorLsaAnalysisRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::RunFleetAdvisorLsaAnalysis, request, handler, context);
        }
 
        virtual Model::StartDataMigrationOutcome StartDataMigration(const Model::StartDataMigrationRequest& request) const;
 
        template<typename StartDataMigrationRequestT = Model::StartDataMigrationRequest>
        Model::StartDataMigrationOutcomeCallable StartDataMigrationCallable(const StartDataMigrationRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::StartDataMigration, request);
        }
 
        template<typename StartDataMigrationRequestT = Model::StartDataMigrationRequest>
        void StartDataMigrationAsync(const StartDataMigrationRequestT& request, const StartDataMigrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::StartDataMigration, request, handler, context);
        }
 
        virtual Model::StartExtensionPackAssociationOutcome StartExtensionPackAssociation(const Model::StartExtensionPackAssociationRequest& request) const;
 
        template<typename StartExtensionPackAssociationRequestT = Model::StartExtensionPackAssociationRequest>
        Model::StartExtensionPackAssociationOutcomeCallable StartExtensionPackAssociationCallable(const StartExtensionPackAssociationRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::StartExtensionPackAssociation, request);
        }
 
        template<typename StartExtensionPackAssociationRequestT = Model::StartExtensionPackAssociationRequest>
        void StartExtensionPackAssociationAsync(const StartExtensionPackAssociationRequestT& request, const StartExtensionPackAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::StartExtensionPackAssociation, request, handler, context);
        }
 
        virtual Model::StartMetadataModelAssessmentOutcome StartMetadataModelAssessment(const Model::StartMetadataModelAssessmentRequest& request) const;
 
        template<typename StartMetadataModelAssessmentRequestT = Model::StartMetadataModelAssessmentRequest>
        Model::StartMetadataModelAssessmentOutcomeCallable StartMetadataModelAssessmentCallable(const StartMetadataModelAssessmentRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::StartMetadataModelAssessment, request);
        }
 
        template<typename StartMetadataModelAssessmentRequestT = Model::StartMetadataModelAssessmentRequest>
        void StartMetadataModelAssessmentAsync(const StartMetadataModelAssessmentRequestT& request, const StartMetadataModelAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::StartMetadataModelAssessment, request, handler, context);
        }
 
        virtual Model::StartMetadataModelConversionOutcome StartMetadataModelConversion(const Model::StartMetadataModelConversionRequest& request) const;
 
        template<typename StartMetadataModelConversionRequestT = Model::StartMetadataModelConversionRequest>
        Model::StartMetadataModelConversionOutcomeCallable StartMetadataModelConversionCallable(const StartMetadataModelConversionRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::StartMetadataModelConversion, request);
        }
 
        template<typename StartMetadataModelConversionRequestT = Model::StartMetadataModelConversionRequest>
        void StartMetadataModelConversionAsync(const StartMetadataModelConversionRequestT& request, const StartMetadataModelConversionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::StartMetadataModelConversion, request, handler, context);
        }
 
        virtual Model::StartMetadataModelExportAsScriptOutcome StartMetadataModelExportAsScript(const Model::StartMetadataModelExportAsScriptRequest& request) const;
 
        template<typename StartMetadataModelExportAsScriptRequestT = Model::StartMetadataModelExportAsScriptRequest>
        Model::StartMetadataModelExportAsScriptOutcomeCallable StartMetadataModelExportAsScriptCallable(const StartMetadataModelExportAsScriptRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::StartMetadataModelExportAsScript, request);
        }
 
        template<typename StartMetadataModelExportAsScriptRequestT = Model::StartMetadataModelExportAsScriptRequest>
        void StartMetadataModelExportAsScriptAsync(const StartMetadataModelExportAsScriptRequestT& request, const StartMetadataModelExportAsScriptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::StartMetadataModelExportAsScript, request, handler, context);
        }
 
        virtual Model::StartMetadataModelExportToTargetOutcome StartMetadataModelExportToTarget(const Model::StartMetadataModelExportToTargetRequest& request) const;
 
        template<typename StartMetadataModelExportToTargetRequestT = Model::StartMetadataModelExportToTargetRequest>
        Model::StartMetadataModelExportToTargetOutcomeCallable StartMetadataModelExportToTargetCallable(const StartMetadataModelExportToTargetRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::StartMetadataModelExportToTarget, request);
        }
 
        template<typename StartMetadataModelExportToTargetRequestT = Model::StartMetadataModelExportToTargetRequest>
        void StartMetadataModelExportToTargetAsync(const StartMetadataModelExportToTargetRequestT& request, const StartMetadataModelExportToTargetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::StartMetadataModelExportToTarget, request, handler, context);
        }
 
        virtual Model::StartMetadataModelImportOutcome StartMetadataModelImport(const Model::StartMetadataModelImportRequest& request) const;
 
        template<typename StartMetadataModelImportRequestT = Model::StartMetadataModelImportRequest>
        Model::StartMetadataModelImportOutcomeCallable StartMetadataModelImportCallable(const StartMetadataModelImportRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::StartMetadataModelImport, request);
        }
 
        template<typename StartMetadataModelImportRequestT = Model::StartMetadataModelImportRequest>
        void StartMetadataModelImportAsync(const StartMetadataModelImportRequestT& request, const StartMetadataModelImportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::StartMetadataModelImport, request, handler, context);
        }
 
        virtual Model::StartRecommendationsOutcome StartRecommendations(const Model::StartRecommendationsRequest& request) const;
 
        template<typename StartRecommendationsRequestT = Model::StartRecommendationsRequest>
        Model::StartRecommendationsOutcomeCallable StartRecommendationsCallable(const StartRecommendationsRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::StartRecommendations, request);
        }
 
        template<typename StartRecommendationsRequestT = Model::StartRecommendationsRequest>
        void StartRecommendationsAsync(const StartRecommendationsRequestT& request, const StartRecommendationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::StartRecommendations, request, handler, context);
        }
 
        virtual Model::StartReplicationOutcome StartReplication(const Model::StartReplicationRequest& request) const;
 
        template<typename StartReplicationRequestT = Model::StartReplicationRequest>
        Model::StartReplicationOutcomeCallable StartReplicationCallable(const StartReplicationRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::StartReplication, request);
        }
 
        template<typename StartReplicationRequestT = Model::StartReplicationRequest>
        void StartReplicationAsync(const StartReplicationRequestT& request, const StartReplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::StartReplication, request, handler, context);
        }
 
        virtual Model::StartReplicationTaskOutcome StartReplicationTask(const Model::StartReplicationTaskRequest& request) const;
 
        template<typename StartReplicationTaskRequestT = Model::StartReplicationTaskRequest>
        Model::StartReplicationTaskOutcomeCallable StartReplicationTaskCallable(const StartReplicationTaskRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::StartReplicationTask, request);
        }
 
        template<typename StartReplicationTaskRequestT = Model::StartReplicationTaskRequest>
        void StartReplicationTaskAsync(const StartReplicationTaskRequestT& request, const StartReplicationTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::StartReplicationTask, request, handler, context);
        }
 
        virtual Model::StartReplicationTaskAssessmentOutcome StartReplicationTaskAssessment(const Model::StartReplicationTaskAssessmentRequest& request) const;
 
        template<typename StartReplicationTaskAssessmentRequestT = Model::StartReplicationTaskAssessmentRequest>
        Model::StartReplicationTaskAssessmentOutcomeCallable StartReplicationTaskAssessmentCallable(const StartReplicationTaskAssessmentRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::StartReplicationTaskAssessment, request);
        }
 
        template<typename StartReplicationTaskAssessmentRequestT = Model::StartReplicationTaskAssessmentRequest>
        void StartReplicationTaskAssessmentAsync(const StartReplicationTaskAssessmentRequestT& request, const StartReplicationTaskAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::StartReplicationTaskAssessment, request, handler, context);
        }
 
        virtual Model::StartReplicationTaskAssessmentRunOutcome StartReplicationTaskAssessmentRun(const Model::StartReplicationTaskAssessmentRunRequest& request) const;
 
        template<typename StartReplicationTaskAssessmentRunRequestT = Model::StartReplicationTaskAssessmentRunRequest>
        Model::StartReplicationTaskAssessmentRunOutcomeCallable StartReplicationTaskAssessmentRunCallable(const StartReplicationTaskAssessmentRunRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::StartReplicationTaskAssessmentRun, request);
        }
 
        template<typename StartReplicationTaskAssessmentRunRequestT = Model::StartReplicationTaskAssessmentRunRequest>
        void StartReplicationTaskAssessmentRunAsync(const StartReplicationTaskAssessmentRunRequestT& request, const StartReplicationTaskAssessmentRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::StartReplicationTaskAssessmentRun, request, handler, context);
        }
 
        virtual Model::StopDataMigrationOutcome StopDataMigration(const Model::StopDataMigrationRequest& request) const;
 
        template<typename StopDataMigrationRequestT = Model::StopDataMigrationRequest>
        Model::StopDataMigrationOutcomeCallable StopDataMigrationCallable(const StopDataMigrationRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::StopDataMigration, request);
        }
 
        template<typename StopDataMigrationRequestT = Model::StopDataMigrationRequest>
        void StopDataMigrationAsync(const StopDataMigrationRequestT& request, const StopDataMigrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::StopDataMigration, request, handler, context);
        }
 
        virtual Model::StopReplicationOutcome StopReplication(const Model::StopReplicationRequest& request) const;
 
        template<typename StopReplicationRequestT = Model::StopReplicationRequest>
        Model::StopReplicationOutcomeCallable StopReplicationCallable(const StopReplicationRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::StopReplication, request);
        }
 
        template<typename StopReplicationRequestT = Model::StopReplicationRequest>
        void StopReplicationAsync(const StopReplicationRequestT& request, const StopReplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::StopReplication, request, handler, context);
        }
 
        virtual Model::StopReplicationTaskOutcome StopReplicationTask(const Model::StopReplicationTaskRequest& request) const;
 
        template<typename StopReplicationTaskRequestT = Model::StopReplicationTaskRequest>
        Model::StopReplicationTaskOutcomeCallable StopReplicationTaskCallable(const StopReplicationTaskRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::StopReplicationTask, request);
        }
 
        template<typename StopReplicationTaskRequestT = Model::StopReplicationTaskRequest>
        void StopReplicationTaskAsync(const StopReplicationTaskRequestT& request, const StopReplicationTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::StopReplicationTask, request, handler, context);
        }
 
        virtual Model::TestConnectionOutcome TestConnection(const Model::TestConnectionRequest& request) const;
 
        template<typename TestConnectionRequestT = Model::TestConnectionRequest>
        Model::TestConnectionOutcomeCallable TestConnectionCallable(const TestConnectionRequestT& request) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::TestConnection, request);
        }
 
        template<typename TestConnectionRequestT = Model::TestConnectionRequest>
        void TestConnectionAsync(const TestConnectionRequestT& request, const TestConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::TestConnection, request, handler, context);
        }
 
        virtual Model::UpdateSubscriptionsToEventBridgeOutcome UpdateSubscriptionsToEventBridge(const Model::UpdateSubscriptionsToEventBridgeRequest& request = {}) const;
 
        template<typename UpdateSubscriptionsToEventBridgeRequestT = Model::UpdateSubscriptionsToEventBridgeRequest>
        Model::UpdateSubscriptionsToEventBridgeOutcomeCallable UpdateSubscriptionsToEventBridgeCallable(const UpdateSubscriptionsToEventBridgeRequestT& request = {}) const
        {
            return SubmitCallable(&DatabaseMigrationServiceClient::UpdateSubscriptionsToEventBridge, request);
        }
 
        template<typename UpdateSubscriptionsToEventBridgeRequestT = Model::UpdateSubscriptionsToEventBridgeRequest>
        void UpdateSubscriptionsToEventBridgeAsync(const UpdateSubscriptionsToEventBridgeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateSubscriptionsToEventBridgeRequestT& request = {}) const
        {
            return SubmitAsync(&DatabaseMigrationServiceClient::UpdateSubscriptionsToEventBridge, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<DatabaseMigrationServiceEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<DatabaseMigrationServiceClient>;
      void init(const DatabaseMigrationServiceClientConfiguration& clientConfiguration);
 
      DatabaseMigrationServiceClientConfiguration m_clientConfiguration;
      std::shared_ptr<DatabaseMigrationServiceEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace DatabaseMigrationService
} // namespace Aws