DatabaseMigrationServiceClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/dms/DatabaseMigrationServiceServiceClientModel.h>
#include <aws/dms/DatabaseMigrationService_EXPORTS.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::CancelMetadataModelConversionOutcome CancelMetadataModelConversion(
      const Model::CancelMetadataModelConversionRequest& request) const;
 
  template <typename CancelMetadataModelConversionRequestT = Model::CancelMetadataModelConversionRequest>
  Model::CancelMetadataModelConversionOutcomeCallable CancelMetadataModelConversionCallable(
      const CancelMetadataModelConversionRequestT& request) const {
    return SubmitCallable(&DatabaseMigrationServiceClient::CancelMetadataModelConversion, request);
  }
 
  template <typename CancelMetadataModelConversionRequestT = Model::CancelMetadataModelConversionRequest>
  void CancelMetadataModelConversionAsync(const CancelMetadataModelConversionRequestT& request,
                                          const CancelMetadataModelConversionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DatabaseMigrationServiceClient::CancelMetadataModelConversion, request, handler, context);
  }
 
  virtual Model::CancelMetadataModelCreationOutcome CancelMetadataModelCreation(
      const Model::CancelMetadataModelCreationRequest& request) const;
 
  template <typename CancelMetadataModelCreationRequestT = Model::CancelMetadataModelCreationRequest>
  Model::CancelMetadataModelCreationOutcomeCallable CancelMetadataModelCreationCallable(
      const CancelMetadataModelCreationRequestT& request) const {
    return SubmitCallable(&DatabaseMigrationServiceClient::CancelMetadataModelCreation, request);
  }
 
  template <typename CancelMetadataModelCreationRequestT = Model::CancelMetadataModelCreationRequest>
  void CancelMetadataModelCreationAsync(const CancelMetadataModelCreationRequestT& request,
                                        const CancelMetadataModelCreationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DatabaseMigrationServiceClient::CancelMetadataModelCreation, 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::DescribeMetadataModelOutcome DescribeMetadataModel(const Model::DescribeMetadataModelRequest& request) const;
 
  template <typename DescribeMetadataModelRequestT = Model::DescribeMetadataModelRequest>
  Model::DescribeMetadataModelOutcomeCallable DescribeMetadataModelCallable(const DescribeMetadataModelRequestT& request) const {
    return SubmitCallable(&DatabaseMigrationServiceClient::DescribeMetadataModel, request);
  }
 
  template <typename DescribeMetadataModelRequestT = Model::DescribeMetadataModelRequest>
  void DescribeMetadataModelAsync(const DescribeMetadataModelRequestT& request, const DescribeMetadataModelResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DatabaseMigrationServiceClient::DescribeMetadataModel, 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::DescribeMetadataModelChildrenOutcome DescribeMetadataModelChildren(
      const Model::DescribeMetadataModelChildrenRequest& request) const;
 
  template <typename DescribeMetadataModelChildrenRequestT = Model::DescribeMetadataModelChildrenRequest>
  Model::DescribeMetadataModelChildrenOutcomeCallable DescribeMetadataModelChildrenCallable(
      const DescribeMetadataModelChildrenRequestT& request) const {
    return SubmitCallable(&DatabaseMigrationServiceClient::DescribeMetadataModelChildren, request);
  }
 
  template <typename DescribeMetadataModelChildrenRequestT = Model::DescribeMetadataModelChildrenRequest>
  void DescribeMetadataModelChildrenAsync(const DescribeMetadataModelChildrenRequestT& request,
                                          const DescribeMetadataModelChildrenResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DatabaseMigrationServiceClient::DescribeMetadataModelChildren, 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::DescribeMetadataModelCreationsOutcome DescribeMetadataModelCreations(
      const Model::DescribeMetadataModelCreationsRequest& request) const;
 
  template <typename DescribeMetadataModelCreationsRequestT = Model::DescribeMetadataModelCreationsRequest>
  Model::DescribeMetadataModelCreationsOutcomeCallable DescribeMetadataModelCreationsCallable(
      const DescribeMetadataModelCreationsRequestT& request) const {
    return SubmitCallable(&DatabaseMigrationServiceClient::DescribeMetadataModelCreations, request);
  }
 
  template <typename DescribeMetadataModelCreationsRequestT = Model::DescribeMetadataModelCreationsRequest>
  void DescribeMetadataModelCreationsAsync(const DescribeMetadataModelCreationsRequestT& request,
                                           const DescribeMetadataModelCreationsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DatabaseMigrationServiceClient::DescribeMetadataModelCreations, 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::GetTargetSelectionRulesOutcome GetTargetSelectionRules(const Model::GetTargetSelectionRulesRequest& request) const;
 
  template <typename GetTargetSelectionRulesRequestT = Model::GetTargetSelectionRulesRequest>
  Model::GetTargetSelectionRulesOutcomeCallable GetTargetSelectionRulesCallable(const GetTargetSelectionRulesRequestT& request) const {
    return SubmitCallable(&DatabaseMigrationServiceClient::GetTargetSelectionRules, request);
  }
 
  template <typename GetTargetSelectionRulesRequestT = Model::GetTargetSelectionRulesRequest>
  void GetTargetSelectionRulesAsync(const GetTargetSelectionRulesRequestT& request,
                                    const GetTargetSelectionRulesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DatabaseMigrationServiceClient::GetTargetSelectionRules, 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::StartMetadataModelCreationOutcome StartMetadataModelCreation(
      const Model::StartMetadataModelCreationRequest& request) const;
 
  template <typename StartMetadataModelCreationRequestT = Model::StartMetadataModelCreationRequest>
  Model::StartMetadataModelCreationOutcomeCallable StartMetadataModelCreationCallable(
      const StartMetadataModelCreationRequestT& request) const {
    return SubmitCallable(&DatabaseMigrationServiceClient::StartMetadataModelCreation, request);
  }
 
  template <typename StartMetadataModelCreationRequestT = Model::StartMetadataModelCreationRequest>
  void StartMetadataModelCreationAsync(const StartMetadataModelCreationRequestT& request,
                                       const StartMetadataModelCreationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DatabaseMigrationServiceClient::StartMetadataModelCreation, 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