MgnClient.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/mgn/MgnPaginationBase.h>
#include <aws/mgn/MgnServiceClientModel.h>
#include <aws/mgn/MgnWaiter.h>
#include <aws/mgn/Mgn_EXPORTS.h>
 
namespace Aws {
namespace mgn {
class AWS_MGN_API MgnClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<MgnClient>,
                              public MgnPaginationBase<MgnClient>,
                              public MgnWaiter<MgnClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef MgnClientConfiguration ClientConfigurationType;
  typedef MgnEndpointProvider EndpointProviderType;
 
  MgnClient(const Aws::mgn::MgnClientConfiguration& clientConfiguration = Aws::mgn::MgnClientConfiguration(),
            std::shared_ptr<MgnEndpointProviderBase> endpointProvider = nullptr);
 
  MgnClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<MgnEndpointProviderBase> endpointProvider = nullptr,
            const Aws::mgn::MgnClientConfiguration& clientConfiguration = Aws::mgn::MgnClientConfiguration());
 
  MgnClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            std::shared_ptr<MgnEndpointProviderBase> endpointProvider = nullptr,
            const Aws::mgn::MgnClientConfiguration& clientConfiguration = Aws::mgn::MgnClientConfiguration());
 
  /* Legacy constructors due deprecation */
  MgnClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MgnClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MgnClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~MgnClient();
 
  virtual Model::ArchiveApplicationOutcome ArchiveApplication(const Model::ArchiveApplicationRequest& request) const;
 
  template <typename ArchiveApplicationRequestT = Model::ArchiveApplicationRequest>
  Model::ArchiveApplicationOutcomeCallable ArchiveApplicationCallable(const ArchiveApplicationRequestT& request) const {
    return SubmitCallable(&MgnClient::ArchiveApplication, request);
  }
 
  template <typename ArchiveApplicationRequestT = Model::ArchiveApplicationRequest>
  void ArchiveApplicationAsync(const ArchiveApplicationRequestT& request, const ArchiveApplicationResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ArchiveApplication, request, handler, context);
  }
 
  virtual Model::ArchiveWaveOutcome ArchiveWave(const Model::ArchiveWaveRequest& request) const;
 
  template <typename ArchiveWaveRequestT = Model::ArchiveWaveRequest>
  Model::ArchiveWaveOutcomeCallable ArchiveWaveCallable(const ArchiveWaveRequestT& request) const {
    return SubmitCallable(&MgnClient::ArchiveWave, request);
  }
 
  template <typename ArchiveWaveRequestT = Model::ArchiveWaveRequest>
  void ArchiveWaveAsync(const ArchiveWaveRequestT& request, const ArchiveWaveResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ArchiveWave, request, handler, context);
  }
 
  virtual Model::AssociateApplicationsOutcome AssociateApplications(const Model::AssociateApplicationsRequest& request) const;
 
  template <typename AssociateApplicationsRequestT = Model::AssociateApplicationsRequest>
  Model::AssociateApplicationsOutcomeCallable AssociateApplicationsCallable(const AssociateApplicationsRequestT& request) const {
    return SubmitCallable(&MgnClient::AssociateApplications, request);
  }
 
  template <typename AssociateApplicationsRequestT = Model::AssociateApplicationsRequest>
  void AssociateApplicationsAsync(const AssociateApplicationsRequestT& request, const AssociateApplicationsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::AssociateApplications, request, handler, context);
  }
 
  virtual Model::AssociateSourceServersOutcome AssociateSourceServers(const Model::AssociateSourceServersRequest& request) const;
 
  template <typename AssociateSourceServersRequestT = Model::AssociateSourceServersRequest>
  Model::AssociateSourceServersOutcomeCallable AssociateSourceServersCallable(const AssociateSourceServersRequestT& request) const {
    return SubmitCallable(&MgnClient::AssociateSourceServers, request);
  }
 
  template <typename AssociateSourceServersRequestT = Model::AssociateSourceServersRequest>
  void AssociateSourceServersAsync(const AssociateSourceServersRequestT& request,
                                   const AssociateSourceServersResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::AssociateSourceServers, request, handler, context);
  }
 
  virtual Model::ChangeServerLifeCycleStateOutcome ChangeServerLifeCycleState(
      const Model::ChangeServerLifeCycleStateRequest& request) const;
 
  template <typename ChangeServerLifeCycleStateRequestT = Model::ChangeServerLifeCycleStateRequest>
  Model::ChangeServerLifeCycleStateOutcomeCallable ChangeServerLifeCycleStateCallable(
      const ChangeServerLifeCycleStateRequestT& request) const {
    return SubmitCallable(&MgnClient::ChangeServerLifeCycleState, request);
  }
 
  template <typename ChangeServerLifeCycleStateRequestT = Model::ChangeServerLifeCycleStateRequest>
  void ChangeServerLifeCycleStateAsync(const ChangeServerLifeCycleStateRequestT& request,
                                       const ChangeServerLifeCycleStateResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ChangeServerLifeCycleState, request, handler, context);
  }
 
  virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request) const;
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request) const {
    return SubmitCallable(&MgnClient::CreateApplication, request);
  }
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  void CreateApplicationAsync(const CreateApplicationRequestT& request, const CreateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::CreateApplication, request, handler, context);
  }
 
  virtual Model::CreateConnectorOutcome CreateConnector(const Model::CreateConnectorRequest& request) const;
 
  template <typename CreateConnectorRequestT = Model::CreateConnectorRequest>
  Model::CreateConnectorOutcomeCallable CreateConnectorCallable(const CreateConnectorRequestT& request) const {
    return SubmitCallable(&MgnClient::CreateConnector, request);
  }
 
  template <typename CreateConnectorRequestT = Model::CreateConnectorRequest>
  void CreateConnectorAsync(const CreateConnectorRequestT& request, const CreateConnectorResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::CreateConnector, request, handler, context);
  }
 
  virtual Model::CreateLaunchConfigurationTemplateOutcome CreateLaunchConfigurationTemplate(
      const Model::CreateLaunchConfigurationTemplateRequest& request = {}) const;
 
  template <typename CreateLaunchConfigurationTemplateRequestT = Model::CreateLaunchConfigurationTemplateRequest>
  Model::CreateLaunchConfigurationTemplateOutcomeCallable CreateLaunchConfigurationTemplateCallable(
      const CreateLaunchConfigurationTemplateRequestT& request = {}) const {
    return SubmitCallable(&MgnClient::CreateLaunchConfigurationTemplate, request);
  }
 
  template <typename CreateLaunchConfigurationTemplateRequestT = Model::CreateLaunchConfigurationTemplateRequest>
  void CreateLaunchConfigurationTemplateAsync(const CreateLaunchConfigurationTemplateResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const CreateLaunchConfigurationTemplateRequestT& request = {}) const {
    return SubmitAsync(&MgnClient::CreateLaunchConfigurationTemplate, request, handler, context);
  }
 
  virtual Model::CreateNetworkMigrationDefinitionOutcome CreateNetworkMigrationDefinition(
      const Model::CreateNetworkMigrationDefinitionRequest& request) const;
 
  template <typename CreateNetworkMigrationDefinitionRequestT = Model::CreateNetworkMigrationDefinitionRequest>
  Model::CreateNetworkMigrationDefinitionOutcomeCallable CreateNetworkMigrationDefinitionCallable(
      const CreateNetworkMigrationDefinitionRequestT& request) const {
    return SubmitCallable(&MgnClient::CreateNetworkMigrationDefinition, request);
  }
 
  template <typename CreateNetworkMigrationDefinitionRequestT = Model::CreateNetworkMigrationDefinitionRequest>
  void CreateNetworkMigrationDefinitionAsync(const CreateNetworkMigrationDefinitionRequestT& request,
                                             const CreateNetworkMigrationDefinitionResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::CreateNetworkMigrationDefinition, request, handler, context);
  }
 
  virtual Model::CreateReplicationConfigurationTemplateOutcome CreateReplicationConfigurationTemplate(
      const Model::CreateReplicationConfigurationTemplateRequest& request) const;
 
  template <typename CreateReplicationConfigurationTemplateRequestT = Model::CreateReplicationConfigurationTemplateRequest>
  Model::CreateReplicationConfigurationTemplateOutcomeCallable CreateReplicationConfigurationTemplateCallable(
      const CreateReplicationConfigurationTemplateRequestT& request) const {
    return SubmitCallable(&MgnClient::CreateReplicationConfigurationTemplate, request);
  }
 
  template <typename CreateReplicationConfigurationTemplateRequestT = Model::CreateReplicationConfigurationTemplateRequest>
  void CreateReplicationConfigurationTemplateAsync(const CreateReplicationConfigurationTemplateRequestT& request,
                                                   const CreateReplicationConfigurationTemplateResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::CreateReplicationConfigurationTemplate, request, handler, context);
  }
 
  virtual Model::CreateWaveOutcome CreateWave(const Model::CreateWaveRequest& request) const;
 
  template <typename CreateWaveRequestT = Model::CreateWaveRequest>
  Model::CreateWaveOutcomeCallable CreateWaveCallable(const CreateWaveRequestT& request) const {
    return SubmitCallable(&MgnClient::CreateWave, request);
  }
 
  template <typename CreateWaveRequestT = Model::CreateWaveRequest>
  void CreateWaveAsync(const CreateWaveRequestT& request, const CreateWaveResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::CreateWave, request, handler, context);
  }
 
  virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const {
    return SubmitCallable(&MgnClient::DeleteApplication, request);
  }
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::DeleteApplication, request, handler, context);
  }
 
  virtual Model::DeleteConnectorOutcome DeleteConnector(const Model::DeleteConnectorRequest& request) const;
 
  template <typename DeleteConnectorRequestT = Model::DeleteConnectorRequest>
  Model::DeleteConnectorOutcomeCallable DeleteConnectorCallable(const DeleteConnectorRequestT& request) const {
    return SubmitCallable(&MgnClient::DeleteConnector, request);
  }
 
  template <typename DeleteConnectorRequestT = Model::DeleteConnectorRequest>
  void DeleteConnectorAsync(const DeleteConnectorRequestT& request, const DeleteConnectorResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::DeleteConnector, request, handler, context);
  }
 
  virtual Model::DeleteJobOutcome DeleteJob(const Model::DeleteJobRequest& request) const;
 
  template <typename DeleteJobRequestT = Model::DeleteJobRequest>
  Model::DeleteJobOutcomeCallable DeleteJobCallable(const DeleteJobRequestT& request) const {
    return SubmitCallable(&MgnClient::DeleteJob, request);
  }
 
  template <typename DeleteJobRequestT = Model::DeleteJobRequest>
  void DeleteJobAsync(const DeleteJobRequestT& request, const DeleteJobResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::DeleteJob, request, handler, context);
  }
 
  virtual Model::DeleteLaunchConfigurationTemplateOutcome DeleteLaunchConfigurationTemplate(
      const Model::DeleteLaunchConfigurationTemplateRequest& request) const;
 
  template <typename DeleteLaunchConfigurationTemplateRequestT = Model::DeleteLaunchConfigurationTemplateRequest>
  Model::DeleteLaunchConfigurationTemplateOutcomeCallable DeleteLaunchConfigurationTemplateCallable(
      const DeleteLaunchConfigurationTemplateRequestT& request) const {
    return SubmitCallable(&MgnClient::DeleteLaunchConfigurationTemplate, request);
  }
 
  template <typename DeleteLaunchConfigurationTemplateRequestT = Model::DeleteLaunchConfigurationTemplateRequest>
  void DeleteLaunchConfigurationTemplateAsync(const DeleteLaunchConfigurationTemplateRequestT& request,
                                              const DeleteLaunchConfigurationTemplateResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::DeleteLaunchConfigurationTemplate, request, handler, context);
  }
 
  virtual Model::DeleteNetworkMigrationDefinitionOutcome DeleteNetworkMigrationDefinition(
      const Model::DeleteNetworkMigrationDefinitionRequest& request) const;
 
  template <typename DeleteNetworkMigrationDefinitionRequestT = Model::DeleteNetworkMigrationDefinitionRequest>
  Model::DeleteNetworkMigrationDefinitionOutcomeCallable DeleteNetworkMigrationDefinitionCallable(
      const DeleteNetworkMigrationDefinitionRequestT& request) const {
    return SubmitCallable(&MgnClient::DeleteNetworkMigrationDefinition, request);
  }
 
  template <typename DeleteNetworkMigrationDefinitionRequestT = Model::DeleteNetworkMigrationDefinitionRequest>
  void DeleteNetworkMigrationDefinitionAsync(const DeleteNetworkMigrationDefinitionRequestT& request,
                                             const DeleteNetworkMigrationDefinitionResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::DeleteNetworkMigrationDefinition, request, handler, context);
  }
 
  virtual Model::DeleteReplicationConfigurationTemplateOutcome DeleteReplicationConfigurationTemplate(
      const Model::DeleteReplicationConfigurationTemplateRequest& request) const;
 
  template <typename DeleteReplicationConfigurationTemplateRequestT = Model::DeleteReplicationConfigurationTemplateRequest>
  Model::DeleteReplicationConfigurationTemplateOutcomeCallable DeleteReplicationConfigurationTemplateCallable(
      const DeleteReplicationConfigurationTemplateRequestT& request) const {
    return SubmitCallable(&MgnClient::DeleteReplicationConfigurationTemplate, request);
  }
 
  template <typename DeleteReplicationConfigurationTemplateRequestT = Model::DeleteReplicationConfigurationTemplateRequest>
  void DeleteReplicationConfigurationTemplateAsync(const DeleteReplicationConfigurationTemplateRequestT& request,
                                                   const DeleteReplicationConfigurationTemplateResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::DeleteReplicationConfigurationTemplate, request, handler, context);
  }
 
  virtual Model::DeleteSourceServerOutcome DeleteSourceServer(const Model::DeleteSourceServerRequest& request) const;
 
  template <typename DeleteSourceServerRequestT = Model::DeleteSourceServerRequest>
  Model::DeleteSourceServerOutcomeCallable DeleteSourceServerCallable(const DeleteSourceServerRequestT& request) const {
    return SubmitCallable(&MgnClient::DeleteSourceServer, request);
  }
 
  template <typename DeleteSourceServerRequestT = Model::DeleteSourceServerRequest>
  void DeleteSourceServerAsync(const DeleteSourceServerRequestT& request, const DeleteSourceServerResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::DeleteSourceServer, request, handler, context);
  }
 
  virtual Model::DeleteVcenterClientOutcome DeleteVcenterClient(const Model::DeleteVcenterClientRequest& request) const;
 
  template <typename DeleteVcenterClientRequestT = Model::DeleteVcenterClientRequest>
  Model::DeleteVcenterClientOutcomeCallable DeleteVcenterClientCallable(const DeleteVcenterClientRequestT& request) const {
    return SubmitCallable(&MgnClient::DeleteVcenterClient, request);
  }
 
  template <typename DeleteVcenterClientRequestT = Model::DeleteVcenterClientRequest>
  void DeleteVcenterClientAsync(const DeleteVcenterClientRequestT& request, const DeleteVcenterClientResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::DeleteVcenterClient, request, handler, context);
  }
 
  virtual Model::DeleteWaveOutcome DeleteWave(const Model::DeleteWaveRequest& request) const;
 
  template <typename DeleteWaveRequestT = Model::DeleteWaveRequest>
  Model::DeleteWaveOutcomeCallable DeleteWaveCallable(const DeleteWaveRequestT& request) const {
    return SubmitCallable(&MgnClient::DeleteWave, request);
  }
 
  template <typename DeleteWaveRequestT = Model::DeleteWaveRequest>
  void DeleteWaveAsync(const DeleteWaveRequestT& request, const DeleteWaveResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::DeleteWave, request, handler, context);
  }
 
  virtual Model::DescribeJobLogItemsOutcome DescribeJobLogItems(const Model::DescribeJobLogItemsRequest& request) const;
 
  template <typename DescribeJobLogItemsRequestT = Model::DescribeJobLogItemsRequest>
  Model::DescribeJobLogItemsOutcomeCallable DescribeJobLogItemsCallable(const DescribeJobLogItemsRequestT& request) const {
    return SubmitCallable(&MgnClient::DescribeJobLogItems, request);
  }
 
  template <typename DescribeJobLogItemsRequestT = Model::DescribeJobLogItemsRequest>
  void DescribeJobLogItemsAsync(const DescribeJobLogItemsRequestT& request, const DescribeJobLogItemsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::DescribeJobLogItems, request, handler, context);
  }
 
  virtual Model::DescribeJobsOutcome DescribeJobs(const Model::DescribeJobsRequest& request = {}) const;
 
  template <typename DescribeJobsRequestT = Model::DescribeJobsRequest>
  Model::DescribeJobsOutcomeCallable DescribeJobsCallable(const DescribeJobsRequestT& request = {}) const {
    return SubmitCallable(&MgnClient::DescribeJobs, request);
  }
 
  template <typename DescribeJobsRequestT = Model::DescribeJobsRequest>
  void DescribeJobsAsync(const DescribeJobsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const DescribeJobsRequestT& request = {}) const {
    return SubmitAsync(&MgnClient::DescribeJobs, request, handler, context);
  }
 
  virtual Model::DescribeLaunchConfigurationTemplatesOutcome DescribeLaunchConfigurationTemplates(
      const Model::DescribeLaunchConfigurationTemplatesRequest& request = {}) const;
 
  template <typename DescribeLaunchConfigurationTemplatesRequestT = Model::DescribeLaunchConfigurationTemplatesRequest>
  Model::DescribeLaunchConfigurationTemplatesOutcomeCallable DescribeLaunchConfigurationTemplatesCallable(
      const DescribeLaunchConfigurationTemplatesRequestT& request = {}) const {
    return SubmitCallable(&MgnClient::DescribeLaunchConfigurationTemplates, request);
  }
 
  template <typename DescribeLaunchConfigurationTemplatesRequestT = Model::DescribeLaunchConfigurationTemplatesRequest>
  void DescribeLaunchConfigurationTemplatesAsync(const DescribeLaunchConfigurationTemplatesResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const DescribeLaunchConfigurationTemplatesRequestT& request = {}) const {
    return SubmitAsync(&MgnClient::DescribeLaunchConfigurationTemplates, request, handler, context);
  }
 
  virtual Model::DescribeReplicationConfigurationTemplatesOutcome DescribeReplicationConfigurationTemplates(
      const Model::DescribeReplicationConfigurationTemplatesRequest& request = {}) const;
 
  template <typename DescribeReplicationConfigurationTemplatesRequestT = Model::DescribeReplicationConfigurationTemplatesRequest>
  Model::DescribeReplicationConfigurationTemplatesOutcomeCallable DescribeReplicationConfigurationTemplatesCallable(
      const DescribeReplicationConfigurationTemplatesRequestT& request = {}) const {
    return SubmitCallable(&MgnClient::DescribeReplicationConfigurationTemplates, request);
  }
 
  template <typename DescribeReplicationConfigurationTemplatesRequestT = Model::DescribeReplicationConfigurationTemplatesRequest>
  void DescribeReplicationConfigurationTemplatesAsync(const DescribeReplicationConfigurationTemplatesResponseReceivedHandler& handler,
                                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                      const DescribeReplicationConfigurationTemplatesRequestT& request = {}) const {
    return SubmitAsync(&MgnClient::DescribeReplicationConfigurationTemplates, request, handler, context);
  }
 
  virtual Model::DescribeSourceServersOutcome DescribeSourceServers(const Model::DescribeSourceServersRequest& request = {}) const;
 
  template <typename DescribeSourceServersRequestT = Model::DescribeSourceServersRequest>
  Model::DescribeSourceServersOutcomeCallable DescribeSourceServersCallable(const DescribeSourceServersRequestT& request = {}) const {
    return SubmitCallable(&MgnClient::DescribeSourceServers, request);
  }
 
  template <typename DescribeSourceServersRequestT = Model::DescribeSourceServersRequest>
  void DescribeSourceServersAsync(const DescribeSourceServersResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const DescribeSourceServersRequestT& request = {}) const {
    return SubmitAsync(&MgnClient::DescribeSourceServers, request, handler, context);
  }
 
  virtual Model::DescribeVcenterClientsOutcome DescribeVcenterClients(const Model::DescribeVcenterClientsRequest& request = {}) const;
 
  template <typename DescribeVcenterClientsRequestT = Model::DescribeVcenterClientsRequest>
  Model::DescribeVcenterClientsOutcomeCallable DescribeVcenterClientsCallable(const DescribeVcenterClientsRequestT& request = {}) const {
    return SubmitCallable(&MgnClient::DescribeVcenterClients, request);
  }
 
  template <typename DescribeVcenterClientsRequestT = Model::DescribeVcenterClientsRequest>
  void DescribeVcenterClientsAsync(const DescribeVcenterClientsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const DescribeVcenterClientsRequestT& request = {}) const {
    return SubmitAsync(&MgnClient::DescribeVcenterClients, request, handler, context);
  }
 
  virtual Model::DisassociateApplicationsOutcome DisassociateApplications(const Model::DisassociateApplicationsRequest& request) const;
 
  template <typename DisassociateApplicationsRequestT = Model::DisassociateApplicationsRequest>
  Model::DisassociateApplicationsOutcomeCallable DisassociateApplicationsCallable(const DisassociateApplicationsRequestT& request) const {
    return SubmitCallable(&MgnClient::DisassociateApplications, request);
  }
 
  template <typename DisassociateApplicationsRequestT = Model::DisassociateApplicationsRequest>
  void DisassociateApplicationsAsync(const DisassociateApplicationsRequestT& request,
                                     const DisassociateApplicationsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::DisassociateApplications, request, handler, context);
  }
 
  virtual Model::DisassociateSourceServersOutcome DisassociateSourceServers(const Model::DisassociateSourceServersRequest& request) const;
 
  template <typename DisassociateSourceServersRequestT = Model::DisassociateSourceServersRequest>
  Model::DisassociateSourceServersOutcomeCallable DisassociateSourceServersCallable(
      const DisassociateSourceServersRequestT& request) const {
    return SubmitCallable(&MgnClient::DisassociateSourceServers, request);
  }
 
  template <typename DisassociateSourceServersRequestT = Model::DisassociateSourceServersRequest>
  void DisassociateSourceServersAsync(const DisassociateSourceServersRequestT& request,
                                      const DisassociateSourceServersResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::DisassociateSourceServers, request, handler, context);
  }
 
  virtual Model::DisconnectFromServiceOutcome DisconnectFromService(const Model::DisconnectFromServiceRequest& request) const;
 
  template <typename DisconnectFromServiceRequestT = Model::DisconnectFromServiceRequest>
  Model::DisconnectFromServiceOutcomeCallable DisconnectFromServiceCallable(const DisconnectFromServiceRequestT& request) const {
    return SubmitCallable(&MgnClient::DisconnectFromService, request);
  }
 
  template <typename DisconnectFromServiceRequestT = Model::DisconnectFromServiceRequest>
  void DisconnectFromServiceAsync(const DisconnectFromServiceRequestT& request, const DisconnectFromServiceResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::DisconnectFromService, request, handler, context);
  }
 
  virtual Model::FinalizeCutoverOutcome FinalizeCutover(const Model::FinalizeCutoverRequest& request) const;
 
  template <typename FinalizeCutoverRequestT = Model::FinalizeCutoverRequest>
  Model::FinalizeCutoverOutcomeCallable FinalizeCutoverCallable(const FinalizeCutoverRequestT& request) const {
    return SubmitCallable(&MgnClient::FinalizeCutover, request);
  }
 
  template <typename FinalizeCutoverRequestT = Model::FinalizeCutoverRequest>
  void FinalizeCutoverAsync(const FinalizeCutoverRequestT& request, const FinalizeCutoverResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::FinalizeCutover, request, handler, context);
  }
 
  virtual Model::GetLaunchConfigurationOutcome GetLaunchConfiguration(const Model::GetLaunchConfigurationRequest& request) const;
 
  template <typename GetLaunchConfigurationRequestT = Model::GetLaunchConfigurationRequest>
  Model::GetLaunchConfigurationOutcomeCallable GetLaunchConfigurationCallable(const GetLaunchConfigurationRequestT& request) const {
    return SubmitCallable(&MgnClient::GetLaunchConfiguration, request);
  }
 
  template <typename GetLaunchConfigurationRequestT = Model::GetLaunchConfigurationRequest>
  void GetLaunchConfigurationAsync(const GetLaunchConfigurationRequestT& request,
                                   const GetLaunchConfigurationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::GetLaunchConfiguration, request, handler, context);
  }
 
  virtual Model::GetNetworkMigrationDefinitionOutcome GetNetworkMigrationDefinition(
      const Model::GetNetworkMigrationDefinitionRequest& request) const;
 
  template <typename GetNetworkMigrationDefinitionRequestT = Model::GetNetworkMigrationDefinitionRequest>
  Model::GetNetworkMigrationDefinitionOutcomeCallable GetNetworkMigrationDefinitionCallable(
      const GetNetworkMigrationDefinitionRequestT& request) const {
    return SubmitCallable(&MgnClient::GetNetworkMigrationDefinition, request);
  }
 
  template <typename GetNetworkMigrationDefinitionRequestT = Model::GetNetworkMigrationDefinitionRequest>
  void GetNetworkMigrationDefinitionAsync(const GetNetworkMigrationDefinitionRequestT& request,
                                          const GetNetworkMigrationDefinitionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::GetNetworkMigrationDefinition, request, handler, context);
  }
 
  virtual Model::GetNetworkMigrationMapperSegmentConstructOutcome GetNetworkMigrationMapperSegmentConstruct(
      const Model::GetNetworkMigrationMapperSegmentConstructRequest& request) const;
 
  template <typename GetNetworkMigrationMapperSegmentConstructRequestT = Model::GetNetworkMigrationMapperSegmentConstructRequest>
  Model::GetNetworkMigrationMapperSegmentConstructOutcomeCallable GetNetworkMigrationMapperSegmentConstructCallable(
      const GetNetworkMigrationMapperSegmentConstructRequestT& request) const {
    return SubmitCallable(&MgnClient::GetNetworkMigrationMapperSegmentConstruct, request);
  }
 
  template <typename GetNetworkMigrationMapperSegmentConstructRequestT = Model::GetNetworkMigrationMapperSegmentConstructRequest>
  void GetNetworkMigrationMapperSegmentConstructAsync(
      const GetNetworkMigrationMapperSegmentConstructRequestT& request,
      const GetNetworkMigrationMapperSegmentConstructResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::GetNetworkMigrationMapperSegmentConstruct, request, handler, context);
  }
 
  virtual Model::GetReplicationConfigurationOutcome GetReplicationConfiguration(
      const Model::GetReplicationConfigurationRequest& request) const;
 
  template <typename GetReplicationConfigurationRequestT = Model::GetReplicationConfigurationRequest>
  Model::GetReplicationConfigurationOutcomeCallable GetReplicationConfigurationCallable(
      const GetReplicationConfigurationRequestT& request) const {
    return SubmitCallable(&MgnClient::GetReplicationConfiguration, request);
  }
 
  template <typename GetReplicationConfigurationRequestT = Model::GetReplicationConfigurationRequest>
  void GetReplicationConfigurationAsync(const GetReplicationConfigurationRequestT& request,
                                        const GetReplicationConfigurationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::GetReplicationConfiguration, request, handler, context);
  }
 
  virtual Model::InitializeServiceOutcome InitializeService(const Model::InitializeServiceRequest& request = {}) const;
 
  template <typename InitializeServiceRequestT = Model::InitializeServiceRequest>
  Model::InitializeServiceOutcomeCallable InitializeServiceCallable(const InitializeServiceRequestT& request = {}) const {
    return SubmitCallable(&MgnClient::InitializeService, request);
  }
 
  template <typename InitializeServiceRequestT = Model::InitializeServiceRequest>
  void InitializeServiceAsync(const InitializeServiceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const InitializeServiceRequestT& request = {}) const {
    return SubmitAsync(&MgnClient::InitializeService, request, handler, context);
  }
 
  virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request = {}) const;
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request = {}) const {
    return SubmitCallable(&MgnClient::ListApplications, request);
  }
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  void ListApplicationsAsync(const ListApplicationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListApplicationsRequestT& request = {}) const {
    return SubmitAsync(&MgnClient::ListApplications, request, handler, context);
  }
 
  virtual Model::ListConnectorsOutcome ListConnectors(const Model::ListConnectorsRequest& request = {}) const;
 
  template <typename ListConnectorsRequestT = Model::ListConnectorsRequest>
  Model::ListConnectorsOutcomeCallable ListConnectorsCallable(const ListConnectorsRequestT& request = {}) const {
    return SubmitCallable(&MgnClient::ListConnectors, request);
  }
 
  template <typename ListConnectorsRequestT = Model::ListConnectorsRequest>
  void ListConnectorsAsync(const ListConnectorsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListConnectorsRequestT& request = {}) const {
    return SubmitAsync(&MgnClient::ListConnectors, request, handler, context);
  }
 
  virtual Model::ListExportErrorsOutcome ListExportErrors(const Model::ListExportErrorsRequest& request) const;
 
  template <typename ListExportErrorsRequestT = Model::ListExportErrorsRequest>
  Model::ListExportErrorsOutcomeCallable ListExportErrorsCallable(const ListExportErrorsRequestT& request) const {
    return SubmitCallable(&MgnClient::ListExportErrors, request);
  }
 
  template <typename ListExportErrorsRequestT = Model::ListExportErrorsRequest>
  void ListExportErrorsAsync(const ListExportErrorsRequestT& request, const ListExportErrorsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ListExportErrors, request, handler, context);
  }
 
  virtual Model::ListExportsOutcome ListExports(const Model::ListExportsRequest& request = {}) const;
 
  template <typename ListExportsRequestT = Model::ListExportsRequest>
  Model::ListExportsOutcomeCallable ListExportsCallable(const ListExportsRequestT& request = {}) const {
    return SubmitCallable(&MgnClient::ListExports, request);
  }
 
  template <typename ListExportsRequestT = Model::ListExportsRequest>
  void ListExportsAsync(const ListExportsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListExportsRequestT& request = {}) const {
    return SubmitAsync(&MgnClient::ListExports, request, handler, context);
  }
 
  virtual Model::ListImportErrorsOutcome ListImportErrors(const Model::ListImportErrorsRequest& request) const;
 
  template <typename ListImportErrorsRequestT = Model::ListImportErrorsRequest>
  Model::ListImportErrorsOutcomeCallable ListImportErrorsCallable(const ListImportErrorsRequestT& request) const {
    return SubmitCallable(&MgnClient::ListImportErrors, request);
  }
 
  template <typename ListImportErrorsRequestT = Model::ListImportErrorsRequest>
  void ListImportErrorsAsync(const ListImportErrorsRequestT& request, const ListImportErrorsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ListImportErrors, request, handler, context);
  }
 
  virtual Model::ListImportFileEnrichmentsOutcome ListImportFileEnrichments(
      const Model::ListImportFileEnrichmentsRequest& request = {}) const;
 
  template <typename ListImportFileEnrichmentsRequestT = Model::ListImportFileEnrichmentsRequest>
  Model::ListImportFileEnrichmentsOutcomeCallable ListImportFileEnrichmentsCallable(
      const ListImportFileEnrichmentsRequestT& request = {}) const {
    return SubmitCallable(&MgnClient::ListImportFileEnrichments, request);
  }
 
  template <typename ListImportFileEnrichmentsRequestT = Model::ListImportFileEnrichmentsRequest>
  void ListImportFileEnrichmentsAsync(const ListImportFileEnrichmentsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListImportFileEnrichmentsRequestT& request = {}) const {
    return SubmitAsync(&MgnClient::ListImportFileEnrichments, request, handler, context);
  }
 
  virtual Model::ListImportsOutcome ListImports(const Model::ListImportsRequest& request = {}) const;
 
  template <typename ListImportsRequestT = Model::ListImportsRequest>
  Model::ListImportsOutcomeCallable ListImportsCallable(const ListImportsRequestT& request = {}) const {
    return SubmitCallable(&MgnClient::ListImports, request);
  }
 
  template <typename ListImportsRequestT = Model::ListImportsRequest>
  void ListImportsAsync(const ListImportsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListImportsRequestT& request = {}) const {
    return SubmitAsync(&MgnClient::ListImports, request, handler, context);
  }
 
  virtual Model::ListManagedAccountsOutcome ListManagedAccounts(const Model::ListManagedAccountsRequest& request = {}) const;
 
  template <typename ListManagedAccountsRequestT = Model::ListManagedAccountsRequest>
  Model::ListManagedAccountsOutcomeCallable ListManagedAccountsCallable(const ListManagedAccountsRequestT& request = {}) const {
    return SubmitCallable(&MgnClient::ListManagedAccounts, request);
  }
 
  template <typename ListManagedAccountsRequestT = Model::ListManagedAccountsRequest>
  void ListManagedAccountsAsync(const ListManagedAccountsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListManagedAccountsRequestT& request = {}) const {
    return SubmitAsync(&MgnClient::ListManagedAccounts, request, handler, context);
  }
 
  virtual Model::ListNetworkMigrationAnalysesOutcome ListNetworkMigrationAnalyses(
      const Model::ListNetworkMigrationAnalysesRequest& request) const;
 
  template <typename ListNetworkMigrationAnalysesRequestT = Model::ListNetworkMigrationAnalysesRequest>
  Model::ListNetworkMigrationAnalysesOutcomeCallable ListNetworkMigrationAnalysesCallable(
      const ListNetworkMigrationAnalysesRequestT& request) const {
    return SubmitCallable(&MgnClient::ListNetworkMigrationAnalyses, request);
  }
 
  template <typename ListNetworkMigrationAnalysesRequestT = Model::ListNetworkMigrationAnalysesRequest>
  void ListNetworkMigrationAnalysesAsync(const ListNetworkMigrationAnalysesRequestT& request,
                                         const ListNetworkMigrationAnalysesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ListNetworkMigrationAnalyses, request, handler, context);
  }
 
  virtual Model::ListNetworkMigrationAnalysisResultsOutcome ListNetworkMigrationAnalysisResults(
      const Model::ListNetworkMigrationAnalysisResultsRequest& request) const;
 
  template <typename ListNetworkMigrationAnalysisResultsRequestT = Model::ListNetworkMigrationAnalysisResultsRequest>
  Model::ListNetworkMigrationAnalysisResultsOutcomeCallable ListNetworkMigrationAnalysisResultsCallable(
      const ListNetworkMigrationAnalysisResultsRequestT& request) const {
    return SubmitCallable(&MgnClient::ListNetworkMigrationAnalysisResults, request);
  }
 
  template <typename ListNetworkMigrationAnalysisResultsRequestT = Model::ListNetworkMigrationAnalysisResultsRequest>
  void ListNetworkMigrationAnalysisResultsAsync(const ListNetworkMigrationAnalysisResultsRequestT& request,
                                                const ListNetworkMigrationAnalysisResultsResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ListNetworkMigrationAnalysisResults, request, handler, context);
  }
 
  virtual Model::ListNetworkMigrationCodeGenerationSegmentsOutcome ListNetworkMigrationCodeGenerationSegments(
      const Model::ListNetworkMigrationCodeGenerationSegmentsRequest& request) const;
 
  template <typename ListNetworkMigrationCodeGenerationSegmentsRequestT = Model::ListNetworkMigrationCodeGenerationSegmentsRequest>
  Model::ListNetworkMigrationCodeGenerationSegmentsOutcomeCallable ListNetworkMigrationCodeGenerationSegmentsCallable(
      const ListNetworkMigrationCodeGenerationSegmentsRequestT& request) const {
    return SubmitCallable(&MgnClient::ListNetworkMigrationCodeGenerationSegments, request);
  }
 
  template <typename ListNetworkMigrationCodeGenerationSegmentsRequestT = Model::ListNetworkMigrationCodeGenerationSegmentsRequest>
  void ListNetworkMigrationCodeGenerationSegmentsAsync(
      const ListNetworkMigrationCodeGenerationSegmentsRequestT& request,
      const ListNetworkMigrationCodeGenerationSegmentsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ListNetworkMigrationCodeGenerationSegments, request, handler, context);
  }
 
  virtual Model::ListNetworkMigrationCodeGenerationsOutcome ListNetworkMigrationCodeGenerations(
      const Model::ListNetworkMigrationCodeGenerationsRequest& request) const;
 
  template <typename ListNetworkMigrationCodeGenerationsRequestT = Model::ListNetworkMigrationCodeGenerationsRequest>
  Model::ListNetworkMigrationCodeGenerationsOutcomeCallable ListNetworkMigrationCodeGenerationsCallable(
      const ListNetworkMigrationCodeGenerationsRequestT& request) const {
    return SubmitCallable(&MgnClient::ListNetworkMigrationCodeGenerations, request);
  }
 
  template <typename ListNetworkMigrationCodeGenerationsRequestT = Model::ListNetworkMigrationCodeGenerationsRequest>
  void ListNetworkMigrationCodeGenerationsAsync(const ListNetworkMigrationCodeGenerationsRequestT& request,
                                                const ListNetworkMigrationCodeGenerationsResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ListNetworkMigrationCodeGenerations, request, handler, context);
  }
 
  virtual Model::ListNetworkMigrationDefinitionsOutcome ListNetworkMigrationDefinitions(
      const Model::ListNetworkMigrationDefinitionsRequest& request = {}) const;
 
  template <typename ListNetworkMigrationDefinitionsRequestT = Model::ListNetworkMigrationDefinitionsRequest>
  Model::ListNetworkMigrationDefinitionsOutcomeCallable ListNetworkMigrationDefinitionsCallable(
      const ListNetworkMigrationDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&MgnClient::ListNetworkMigrationDefinitions, request);
  }
 
  template <typename ListNetworkMigrationDefinitionsRequestT = Model::ListNetworkMigrationDefinitionsRequest>
  void ListNetworkMigrationDefinitionsAsync(const ListNetworkMigrationDefinitionsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const ListNetworkMigrationDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&MgnClient::ListNetworkMigrationDefinitions, request, handler, context);
  }
 
  virtual Model::ListNetworkMigrationDeployedStacksOutcome ListNetworkMigrationDeployedStacks(
      const Model::ListNetworkMigrationDeployedStacksRequest& request) const;
 
  template <typename ListNetworkMigrationDeployedStacksRequestT = Model::ListNetworkMigrationDeployedStacksRequest>
  Model::ListNetworkMigrationDeployedStacksOutcomeCallable ListNetworkMigrationDeployedStacksCallable(
      const ListNetworkMigrationDeployedStacksRequestT& request) const {
    return SubmitCallable(&MgnClient::ListNetworkMigrationDeployedStacks, request);
  }
 
  template <typename ListNetworkMigrationDeployedStacksRequestT = Model::ListNetworkMigrationDeployedStacksRequest>
  void ListNetworkMigrationDeployedStacksAsync(const ListNetworkMigrationDeployedStacksRequestT& request,
                                               const ListNetworkMigrationDeployedStacksResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ListNetworkMigrationDeployedStacks, request, handler, context);
  }
 
  virtual Model::ListNetworkMigrationDeploymentsOutcome ListNetworkMigrationDeployments(
      const Model::ListNetworkMigrationDeploymentsRequest& request) const;
 
  template <typename ListNetworkMigrationDeploymentsRequestT = Model::ListNetworkMigrationDeploymentsRequest>
  Model::ListNetworkMigrationDeploymentsOutcomeCallable ListNetworkMigrationDeploymentsCallable(
      const ListNetworkMigrationDeploymentsRequestT& request) const {
    return SubmitCallable(&MgnClient::ListNetworkMigrationDeployments, request);
  }
 
  template <typename ListNetworkMigrationDeploymentsRequestT = Model::ListNetworkMigrationDeploymentsRequest>
  void ListNetworkMigrationDeploymentsAsync(const ListNetworkMigrationDeploymentsRequestT& request,
                                            const ListNetworkMigrationDeploymentsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ListNetworkMigrationDeployments, request, handler, context);
  }
 
  virtual Model::ListNetworkMigrationExecutionsOutcome ListNetworkMigrationExecutions(
      const Model::ListNetworkMigrationExecutionsRequest& request) const;
 
  template <typename ListNetworkMigrationExecutionsRequestT = Model::ListNetworkMigrationExecutionsRequest>
  Model::ListNetworkMigrationExecutionsOutcomeCallable ListNetworkMigrationExecutionsCallable(
      const ListNetworkMigrationExecutionsRequestT& request) const {
    return SubmitCallable(&MgnClient::ListNetworkMigrationExecutions, request);
  }
 
  template <typename ListNetworkMigrationExecutionsRequestT = Model::ListNetworkMigrationExecutionsRequest>
  void ListNetworkMigrationExecutionsAsync(const ListNetworkMigrationExecutionsRequestT& request,
                                           const ListNetworkMigrationExecutionsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ListNetworkMigrationExecutions, request, handler, context);
  }
 
  virtual Model::ListNetworkMigrationMapperSegmentConstructsOutcome ListNetworkMigrationMapperSegmentConstructs(
      const Model::ListNetworkMigrationMapperSegmentConstructsRequest& request) const;
 
  template <typename ListNetworkMigrationMapperSegmentConstructsRequestT = Model::ListNetworkMigrationMapperSegmentConstructsRequest>
  Model::ListNetworkMigrationMapperSegmentConstructsOutcomeCallable ListNetworkMigrationMapperSegmentConstructsCallable(
      const ListNetworkMigrationMapperSegmentConstructsRequestT& request) const {
    return SubmitCallable(&MgnClient::ListNetworkMigrationMapperSegmentConstructs, request);
  }
 
  template <typename ListNetworkMigrationMapperSegmentConstructsRequestT = Model::ListNetworkMigrationMapperSegmentConstructsRequest>
  void ListNetworkMigrationMapperSegmentConstructsAsync(
      const ListNetworkMigrationMapperSegmentConstructsRequestT& request,
      const ListNetworkMigrationMapperSegmentConstructsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ListNetworkMigrationMapperSegmentConstructs, request, handler, context);
  }
 
  virtual Model::ListNetworkMigrationMapperSegmentsOutcome ListNetworkMigrationMapperSegments(
      const Model::ListNetworkMigrationMapperSegmentsRequest& request) const;
 
  template <typename ListNetworkMigrationMapperSegmentsRequestT = Model::ListNetworkMigrationMapperSegmentsRequest>
  Model::ListNetworkMigrationMapperSegmentsOutcomeCallable ListNetworkMigrationMapperSegmentsCallable(
      const ListNetworkMigrationMapperSegmentsRequestT& request) const {
    return SubmitCallable(&MgnClient::ListNetworkMigrationMapperSegments, request);
  }
 
  template <typename ListNetworkMigrationMapperSegmentsRequestT = Model::ListNetworkMigrationMapperSegmentsRequest>
  void ListNetworkMigrationMapperSegmentsAsync(const ListNetworkMigrationMapperSegmentsRequestT& request,
                                               const ListNetworkMigrationMapperSegmentsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ListNetworkMigrationMapperSegments, request, handler, context);
  }
 
  virtual Model::ListNetworkMigrationMappingUpdatesOutcome ListNetworkMigrationMappingUpdates(
      const Model::ListNetworkMigrationMappingUpdatesRequest& request) const;
 
  template <typename ListNetworkMigrationMappingUpdatesRequestT = Model::ListNetworkMigrationMappingUpdatesRequest>
  Model::ListNetworkMigrationMappingUpdatesOutcomeCallable ListNetworkMigrationMappingUpdatesCallable(
      const ListNetworkMigrationMappingUpdatesRequestT& request) const {
    return SubmitCallable(&MgnClient::ListNetworkMigrationMappingUpdates, request);
  }
 
  template <typename ListNetworkMigrationMappingUpdatesRequestT = Model::ListNetworkMigrationMappingUpdatesRequest>
  void ListNetworkMigrationMappingUpdatesAsync(const ListNetworkMigrationMappingUpdatesRequestT& request,
                                               const ListNetworkMigrationMappingUpdatesResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ListNetworkMigrationMappingUpdates, request, handler, context);
  }
 
  virtual Model::ListNetworkMigrationMappingsOutcome ListNetworkMigrationMappings(
      const Model::ListNetworkMigrationMappingsRequest& request) const;
 
  template <typename ListNetworkMigrationMappingsRequestT = Model::ListNetworkMigrationMappingsRequest>
  Model::ListNetworkMigrationMappingsOutcomeCallable ListNetworkMigrationMappingsCallable(
      const ListNetworkMigrationMappingsRequestT& request) const {
    return SubmitCallable(&MgnClient::ListNetworkMigrationMappings, request);
  }
 
  template <typename ListNetworkMigrationMappingsRequestT = Model::ListNetworkMigrationMappingsRequest>
  void ListNetworkMigrationMappingsAsync(const ListNetworkMigrationMappingsRequestT& request,
                                         const ListNetworkMigrationMappingsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ListNetworkMigrationMappings, request, handler, context);
  }
 
  virtual Model::ListSourceServerActionsOutcome ListSourceServerActions(const Model::ListSourceServerActionsRequest& request) const;
 
  template <typename ListSourceServerActionsRequestT = Model::ListSourceServerActionsRequest>
  Model::ListSourceServerActionsOutcomeCallable ListSourceServerActionsCallable(const ListSourceServerActionsRequestT& request) const {
    return SubmitCallable(&MgnClient::ListSourceServerActions, request);
  }
 
  template <typename ListSourceServerActionsRequestT = Model::ListSourceServerActionsRequest>
  void ListSourceServerActionsAsync(const ListSourceServerActionsRequestT& request,
                                    const ListSourceServerActionsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ListSourceServerActions, 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(&MgnClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTemplateActionsOutcome ListTemplateActions(const Model::ListTemplateActionsRequest& request) const;
 
  template <typename ListTemplateActionsRequestT = Model::ListTemplateActionsRequest>
  Model::ListTemplateActionsOutcomeCallable ListTemplateActionsCallable(const ListTemplateActionsRequestT& request) const {
    return SubmitCallable(&MgnClient::ListTemplateActions, request);
  }
 
  template <typename ListTemplateActionsRequestT = Model::ListTemplateActionsRequest>
  void ListTemplateActionsAsync(const ListTemplateActionsRequestT& request, const ListTemplateActionsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ListTemplateActions, request, handler, context);
  }
 
  virtual Model::ListWavesOutcome ListWaves(const Model::ListWavesRequest& request = {}) const;
 
  template <typename ListWavesRequestT = Model::ListWavesRequest>
  Model::ListWavesOutcomeCallable ListWavesCallable(const ListWavesRequestT& request = {}) const {
    return SubmitCallable(&MgnClient::ListWaves, request);
  }
 
  template <typename ListWavesRequestT = Model::ListWavesRequest>
  void ListWavesAsync(const ListWavesResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const ListWavesRequestT& request = {}) const {
    return SubmitAsync(&MgnClient::ListWaves, request, handler, context);
  }
 
  virtual Model::MarkAsArchivedOutcome MarkAsArchived(const Model::MarkAsArchivedRequest& request) const;
 
  template <typename MarkAsArchivedRequestT = Model::MarkAsArchivedRequest>
  Model::MarkAsArchivedOutcomeCallable MarkAsArchivedCallable(const MarkAsArchivedRequestT& request) const {
    return SubmitCallable(&MgnClient::MarkAsArchived, request);
  }
 
  template <typename MarkAsArchivedRequestT = Model::MarkAsArchivedRequest>
  void MarkAsArchivedAsync(const MarkAsArchivedRequestT& request, const MarkAsArchivedResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::MarkAsArchived, request, handler, context);
  }
 
  virtual Model::PauseReplicationOutcome PauseReplication(const Model::PauseReplicationRequest& request) const;
 
  template <typename PauseReplicationRequestT = Model::PauseReplicationRequest>
  Model::PauseReplicationOutcomeCallable PauseReplicationCallable(const PauseReplicationRequestT& request) const {
    return SubmitCallable(&MgnClient::PauseReplication, request);
  }
 
  template <typename PauseReplicationRequestT = Model::PauseReplicationRequest>
  void PauseReplicationAsync(const PauseReplicationRequestT& request, const PauseReplicationResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::PauseReplication, request, handler, context);
  }
 
  virtual Model::PutSourceServerActionOutcome PutSourceServerAction(const Model::PutSourceServerActionRequest& request) const;
 
  template <typename PutSourceServerActionRequestT = Model::PutSourceServerActionRequest>
  Model::PutSourceServerActionOutcomeCallable PutSourceServerActionCallable(const PutSourceServerActionRequestT& request) const {
    return SubmitCallable(&MgnClient::PutSourceServerAction, request);
  }
 
  template <typename PutSourceServerActionRequestT = Model::PutSourceServerActionRequest>
  void PutSourceServerActionAsync(const PutSourceServerActionRequestT& request, const PutSourceServerActionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::PutSourceServerAction, request, handler, context);
  }
 
  virtual Model::PutTemplateActionOutcome PutTemplateAction(const Model::PutTemplateActionRequest& request) const;
 
  template <typename PutTemplateActionRequestT = Model::PutTemplateActionRequest>
  Model::PutTemplateActionOutcomeCallable PutTemplateActionCallable(const PutTemplateActionRequestT& request) const {
    return SubmitCallable(&MgnClient::PutTemplateAction, request);
  }
 
  template <typename PutTemplateActionRequestT = Model::PutTemplateActionRequest>
  void PutTemplateActionAsync(const PutTemplateActionRequestT& request, const PutTemplateActionResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::PutTemplateAction, request, handler, context);
  }
 
  virtual Model::RemoveSourceServerActionOutcome RemoveSourceServerAction(const Model::RemoveSourceServerActionRequest& request) const;
 
  template <typename RemoveSourceServerActionRequestT = Model::RemoveSourceServerActionRequest>
  Model::RemoveSourceServerActionOutcomeCallable RemoveSourceServerActionCallable(const RemoveSourceServerActionRequestT& request) const {
    return SubmitCallable(&MgnClient::RemoveSourceServerAction, request);
  }
 
  template <typename RemoveSourceServerActionRequestT = Model::RemoveSourceServerActionRequest>
  void RemoveSourceServerActionAsync(const RemoveSourceServerActionRequestT& request,
                                     const RemoveSourceServerActionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::RemoveSourceServerAction, request, handler, context);
  }
 
  virtual Model::RemoveTemplateActionOutcome RemoveTemplateAction(const Model::RemoveTemplateActionRequest& request) const;
 
  template <typename RemoveTemplateActionRequestT = Model::RemoveTemplateActionRequest>
  Model::RemoveTemplateActionOutcomeCallable RemoveTemplateActionCallable(const RemoveTemplateActionRequestT& request) const {
    return SubmitCallable(&MgnClient::RemoveTemplateAction, request);
  }
 
  template <typename RemoveTemplateActionRequestT = Model::RemoveTemplateActionRequest>
  void RemoveTemplateActionAsync(const RemoveTemplateActionRequestT& request, const RemoveTemplateActionResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::RemoveTemplateAction, request, handler, context);
  }
 
  virtual Model::ResumeReplicationOutcome ResumeReplication(const Model::ResumeReplicationRequest& request) const;
 
  template <typename ResumeReplicationRequestT = Model::ResumeReplicationRequest>
  Model::ResumeReplicationOutcomeCallable ResumeReplicationCallable(const ResumeReplicationRequestT& request) const {
    return SubmitCallable(&MgnClient::ResumeReplication, request);
  }
 
  template <typename ResumeReplicationRequestT = Model::ResumeReplicationRequest>
  void ResumeReplicationAsync(const ResumeReplicationRequestT& request, const ResumeReplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::ResumeReplication, request, handler, context);
  }
 
  virtual Model::RetryDataReplicationOutcome RetryDataReplication(const Model::RetryDataReplicationRequest& request) const;
 
  template <typename RetryDataReplicationRequestT = Model::RetryDataReplicationRequest>
  Model::RetryDataReplicationOutcomeCallable RetryDataReplicationCallable(const RetryDataReplicationRequestT& request) const {
    return SubmitCallable(&MgnClient::RetryDataReplication, request);
  }
 
  template <typename RetryDataReplicationRequestT = Model::RetryDataReplicationRequest>
  void RetryDataReplicationAsync(const RetryDataReplicationRequestT& request, const RetryDataReplicationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::RetryDataReplication, request, handler, context);
  }
 
  virtual Model::StartCutoverOutcome StartCutover(const Model::StartCutoverRequest& request) const;
 
  template <typename StartCutoverRequestT = Model::StartCutoverRequest>
  Model::StartCutoverOutcomeCallable StartCutoverCallable(const StartCutoverRequestT& request) const {
    return SubmitCallable(&MgnClient::StartCutover, request);
  }
 
  template <typename StartCutoverRequestT = Model::StartCutoverRequest>
  void StartCutoverAsync(const StartCutoverRequestT& request, const StartCutoverResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::StartCutover, request, handler, context);
  }
 
  virtual Model::StartExportOutcome StartExport(const Model::StartExportRequest& request) const;
 
  template <typename StartExportRequestT = Model::StartExportRequest>
  Model::StartExportOutcomeCallable StartExportCallable(const StartExportRequestT& request) const {
    return SubmitCallable(&MgnClient::StartExport, request);
  }
 
  template <typename StartExportRequestT = Model::StartExportRequest>
  void StartExportAsync(const StartExportRequestT& request, const StartExportResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::StartExport, request, handler, context);
  }
 
  virtual Model::StartImportOutcome StartImport(const Model::StartImportRequest& request) const;
 
  template <typename StartImportRequestT = Model::StartImportRequest>
  Model::StartImportOutcomeCallable StartImportCallable(const StartImportRequestT& request) const {
    return SubmitCallable(&MgnClient::StartImport, request);
  }
 
  template <typename StartImportRequestT = Model::StartImportRequest>
  void StartImportAsync(const StartImportRequestT& request, const StartImportResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::StartImport, request, handler, context);
  }
 
  virtual Model::StartImportFileEnrichmentOutcome StartImportFileEnrichment(const Model::StartImportFileEnrichmentRequest& request) const;
 
  template <typename StartImportFileEnrichmentRequestT = Model::StartImportFileEnrichmentRequest>
  Model::StartImportFileEnrichmentOutcomeCallable StartImportFileEnrichmentCallable(
      const StartImportFileEnrichmentRequestT& request) const {
    return SubmitCallable(&MgnClient::StartImportFileEnrichment, request);
  }
 
  template <typename StartImportFileEnrichmentRequestT = Model::StartImportFileEnrichmentRequest>
  void StartImportFileEnrichmentAsync(const StartImportFileEnrichmentRequestT& request,
                                      const StartImportFileEnrichmentResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::StartImportFileEnrichment, request, handler, context);
  }
 
  virtual Model::StartNetworkMigrationAnalysisOutcome StartNetworkMigrationAnalysis(
      const Model::StartNetworkMigrationAnalysisRequest& request) const;
 
  template <typename StartNetworkMigrationAnalysisRequestT = Model::StartNetworkMigrationAnalysisRequest>
  Model::StartNetworkMigrationAnalysisOutcomeCallable StartNetworkMigrationAnalysisCallable(
      const StartNetworkMigrationAnalysisRequestT& request) const {
    return SubmitCallable(&MgnClient::StartNetworkMigrationAnalysis, request);
  }
 
  template <typename StartNetworkMigrationAnalysisRequestT = Model::StartNetworkMigrationAnalysisRequest>
  void StartNetworkMigrationAnalysisAsync(const StartNetworkMigrationAnalysisRequestT& request,
                                          const StartNetworkMigrationAnalysisResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::StartNetworkMigrationAnalysis, request, handler, context);
  }
 
  virtual Model::StartNetworkMigrationCodeGenerationOutcome StartNetworkMigrationCodeGeneration(
      const Model::StartNetworkMigrationCodeGenerationRequest& request) const;
 
  template <typename StartNetworkMigrationCodeGenerationRequestT = Model::StartNetworkMigrationCodeGenerationRequest>
  Model::StartNetworkMigrationCodeGenerationOutcomeCallable StartNetworkMigrationCodeGenerationCallable(
      const StartNetworkMigrationCodeGenerationRequestT& request) const {
    return SubmitCallable(&MgnClient::StartNetworkMigrationCodeGeneration, request);
  }
 
  template <typename StartNetworkMigrationCodeGenerationRequestT = Model::StartNetworkMigrationCodeGenerationRequest>
  void StartNetworkMigrationCodeGenerationAsync(const StartNetworkMigrationCodeGenerationRequestT& request,
                                                const StartNetworkMigrationCodeGenerationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::StartNetworkMigrationCodeGeneration, request, handler, context);
  }
 
  virtual Model::StartNetworkMigrationDeploymentOutcome StartNetworkMigrationDeployment(
      const Model::StartNetworkMigrationDeploymentRequest& request) const;
 
  template <typename StartNetworkMigrationDeploymentRequestT = Model::StartNetworkMigrationDeploymentRequest>
  Model::StartNetworkMigrationDeploymentOutcomeCallable StartNetworkMigrationDeploymentCallable(
      const StartNetworkMigrationDeploymentRequestT& request) const {
    return SubmitCallable(&MgnClient::StartNetworkMigrationDeployment, request);
  }
 
  template <typename StartNetworkMigrationDeploymentRequestT = Model::StartNetworkMigrationDeploymentRequest>
  void StartNetworkMigrationDeploymentAsync(const StartNetworkMigrationDeploymentRequestT& request,
                                            const StartNetworkMigrationDeploymentResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::StartNetworkMigrationDeployment, request, handler, context);
  }
 
  virtual Model::StartNetworkMigrationMappingOutcome StartNetworkMigrationMapping(
      const Model::StartNetworkMigrationMappingRequest& request) const;
 
  template <typename StartNetworkMigrationMappingRequestT = Model::StartNetworkMigrationMappingRequest>
  Model::StartNetworkMigrationMappingOutcomeCallable StartNetworkMigrationMappingCallable(
      const StartNetworkMigrationMappingRequestT& request) const {
    return SubmitCallable(&MgnClient::StartNetworkMigrationMapping, request);
  }
 
  template <typename StartNetworkMigrationMappingRequestT = Model::StartNetworkMigrationMappingRequest>
  void StartNetworkMigrationMappingAsync(const StartNetworkMigrationMappingRequestT& request,
                                         const StartNetworkMigrationMappingResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::StartNetworkMigrationMapping, request, handler, context);
  }
 
  virtual Model::StartNetworkMigrationMappingUpdateOutcome StartNetworkMigrationMappingUpdate(
      const Model::StartNetworkMigrationMappingUpdateRequest& request) const;
 
  template <typename StartNetworkMigrationMappingUpdateRequestT = Model::StartNetworkMigrationMappingUpdateRequest>
  Model::StartNetworkMigrationMappingUpdateOutcomeCallable StartNetworkMigrationMappingUpdateCallable(
      const StartNetworkMigrationMappingUpdateRequestT& request) const {
    return SubmitCallable(&MgnClient::StartNetworkMigrationMappingUpdate, request);
  }
 
  template <typename StartNetworkMigrationMappingUpdateRequestT = Model::StartNetworkMigrationMappingUpdateRequest>
  void StartNetworkMigrationMappingUpdateAsync(const StartNetworkMigrationMappingUpdateRequestT& request,
                                               const StartNetworkMigrationMappingUpdateResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::StartNetworkMigrationMappingUpdate, 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(&MgnClient::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(&MgnClient::StartReplication, request, handler, context);
  }
 
  virtual Model::StartTestOutcome StartTest(const Model::StartTestRequest& request) const;
 
  template <typename StartTestRequestT = Model::StartTestRequest>
  Model::StartTestOutcomeCallable StartTestCallable(const StartTestRequestT& request) const {
    return SubmitCallable(&MgnClient::StartTest, request);
  }
 
  template <typename StartTestRequestT = Model::StartTestRequest>
  void StartTestAsync(const StartTestRequestT& request, const StartTestResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::StartTest, 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(&MgnClient::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(&MgnClient::StopReplication, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&MgnClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::TagResource, request, handler, context);
  }
 
  virtual Model::TerminateTargetInstancesOutcome TerminateTargetInstances(const Model::TerminateTargetInstancesRequest& request) const;
 
  template <typename TerminateTargetInstancesRequestT = Model::TerminateTargetInstancesRequest>
  Model::TerminateTargetInstancesOutcomeCallable TerminateTargetInstancesCallable(const TerminateTargetInstancesRequestT& request) const {
    return SubmitCallable(&MgnClient::TerminateTargetInstances, request);
  }
 
  template <typename TerminateTargetInstancesRequestT = Model::TerminateTargetInstancesRequest>
  void TerminateTargetInstancesAsync(const TerminateTargetInstancesRequestT& request,
                                     const TerminateTargetInstancesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::TerminateTargetInstances, request, handler, context);
  }
 
  virtual Model::UnarchiveApplicationOutcome UnarchiveApplication(const Model::UnarchiveApplicationRequest& request) const;
 
  template <typename UnarchiveApplicationRequestT = Model::UnarchiveApplicationRequest>
  Model::UnarchiveApplicationOutcomeCallable UnarchiveApplicationCallable(const UnarchiveApplicationRequestT& request) const {
    return SubmitCallable(&MgnClient::UnarchiveApplication, request);
  }
 
  template <typename UnarchiveApplicationRequestT = Model::UnarchiveApplicationRequest>
  void UnarchiveApplicationAsync(const UnarchiveApplicationRequestT& request, const UnarchiveApplicationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::UnarchiveApplication, request, handler, context);
  }
 
  virtual Model::UnarchiveWaveOutcome UnarchiveWave(const Model::UnarchiveWaveRequest& request) const;
 
  template <typename UnarchiveWaveRequestT = Model::UnarchiveWaveRequest>
  Model::UnarchiveWaveOutcomeCallable UnarchiveWaveCallable(const UnarchiveWaveRequestT& request) const {
    return SubmitCallable(&MgnClient::UnarchiveWave, request);
  }
 
  template <typename UnarchiveWaveRequestT = Model::UnarchiveWaveRequest>
  void UnarchiveWaveAsync(const UnarchiveWaveRequestT& request, const UnarchiveWaveResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::UnarchiveWave, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&MgnClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request) const;
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request) const {
    return SubmitCallable(&MgnClient::UpdateApplication, request);
  }
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  void UpdateApplicationAsync(const UpdateApplicationRequestT& request, const UpdateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::UpdateApplication, request, handler, context);
  }
 
  virtual Model::UpdateConnectorOutcome UpdateConnector(const Model::UpdateConnectorRequest& request) const;
 
  template <typename UpdateConnectorRequestT = Model::UpdateConnectorRequest>
  Model::UpdateConnectorOutcomeCallable UpdateConnectorCallable(const UpdateConnectorRequestT& request) const {
    return SubmitCallable(&MgnClient::UpdateConnector, request);
  }
 
  template <typename UpdateConnectorRequestT = Model::UpdateConnectorRequest>
  void UpdateConnectorAsync(const UpdateConnectorRequestT& request, const UpdateConnectorResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::UpdateConnector, request, handler, context);
  }
 
  virtual Model::UpdateLaunchConfigurationOutcome UpdateLaunchConfiguration(const Model::UpdateLaunchConfigurationRequest& request) const;
 
  template <typename UpdateLaunchConfigurationRequestT = Model::UpdateLaunchConfigurationRequest>
  Model::UpdateLaunchConfigurationOutcomeCallable UpdateLaunchConfigurationCallable(
      const UpdateLaunchConfigurationRequestT& request) const {
    return SubmitCallable(&MgnClient::UpdateLaunchConfiguration, request);
  }
 
  template <typename UpdateLaunchConfigurationRequestT = Model::UpdateLaunchConfigurationRequest>
  void UpdateLaunchConfigurationAsync(const UpdateLaunchConfigurationRequestT& request,
                                      const UpdateLaunchConfigurationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::UpdateLaunchConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateLaunchConfigurationTemplateOutcome UpdateLaunchConfigurationTemplate(
      const Model::UpdateLaunchConfigurationTemplateRequest& request) const;
 
  template <typename UpdateLaunchConfigurationTemplateRequestT = Model::UpdateLaunchConfigurationTemplateRequest>
  Model::UpdateLaunchConfigurationTemplateOutcomeCallable UpdateLaunchConfigurationTemplateCallable(
      const UpdateLaunchConfigurationTemplateRequestT& request) const {
    return SubmitCallable(&MgnClient::UpdateLaunchConfigurationTemplate, request);
  }
 
  template <typename UpdateLaunchConfigurationTemplateRequestT = Model::UpdateLaunchConfigurationTemplateRequest>
  void UpdateLaunchConfigurationTemplateAsync(const UpdateLaunchConfigurationTemplateRequestT& request,
                                              const UpdateLaunchConfigurationTemplateResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::UpdateLaunchConfigurationTemplate, request, handler, context);
  }
 
  virtual Model::UpdateNetworkMigrationDefinitionOutcome UpdateNetworkMigrationDefinition(
      const Model::UpdateNetworkMigrationDefinitionRequest& request) const;
 
  template <typename UpdateNetworkMigrationDefinitionRequestT = Model::UpdateNetworkMigrationDefinitionRequest>
  Model::UpdateNetworkMigrationDefinitionOutcomeCallable UpdateNetworkMigrationDefinitionCallable(
      const UpdateNetworkMigrationDefinitionRequestT& request) const {
    return SubmitCallable(&MgnClient::UpdateNetworkMigrationDefinition, request);
  }
 
  template <typename UpdateNetworkMigrationDefinitionRequestT = Model::UpdateNetworkMigrationDefinitionRequest>
  void UpdateNetworkMigrationDefinitionAsync(const UpdateNetworkMigrationDefinitionRequestT& request,
                                             const UpdateNetworkMigrationDefinitionResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::UpdateNetworkMigrationDefinition, request, handler, context);
  }
 
  virtual Model::UpdateNetworkMigrationMapperSegmentOutcome UpdateNetworkMigrationMapperSegment(
      const Model::UpdateNetworkMigrationMapperSegmentRequest& request) const;
 
  template <typename UpdateNetworkMigrationMapperSegmentRequestT = Model::UpdateNetworkMigrationMapperSegmentRequest>
  Model::UpdateNetworkMigrationMapperSegmentOutcomeCallable UpdateNetworkMigrationMapperSegmentCallable(
      const UpdateNetworkMigrationMapperSegmentRequestT& request) const {
    return SubmitCallable(&MgnClient::UpdateNetworkMigrationMapperSegment, request);
  }
 
  template <typename UpdateNetworkMigrationMapperSegmentRequestT = Model::UpdateNetworkMigrationMapperSegmentRequest>
  void UpdateNetworkMigrationMapperSegmentAsync(const UpdateNetworkMigrationMapperSegmentRequestT& request,
                                                const UpdateNetworkMigrationMapperSegmentResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::UpdateNetworkMigrationMapperSegment, request, handler, context);
  }
 
  virtual Model::UpdateReplicationConfigurationOutcome UpdateReplicationConfiguration(
      const Model::UpdateReplicationConfigurationRequest& request) const;
 
  template <typename UpdateReplicationConfigurationRequestT = Model::UpdateReplicationConfigurationRequest>
  Model::UpdateReplicationConfigurationOutcomeCallable UpdateReplicationConfigurationCallable(
      const UpdateReplicationConfigurationRequestT& request) const {
    return SubmitCallable(&MgnClient::UpdateReplicationConfiguration, request);
  }
 
  template <typename UpdateReplicationConfigurationRequestT = Model::UpdateReplicationConfigurationRequest>
  void UpdateReplicationConfigurationAsync(const UpdateReplicationConfigurationRequestT& request,
                                           const UpdateReplicationConfigurationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::UpdateReplicationConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateReplicationConfigurationTemplateOutcome UpdateReplicationConfigurationTemplate(
      const Model::UpdateReplicationConfigurationTemplateRequest& request) const;
 
  template <typename UpdateReplicationConfigurationTemplateRequestT = Model::UpdateReplicationConfigurationTemplateRequest>
  Model::UpdateReplicationConfigurationTemplateOutcomeCallable UpdateReplicationConfigurationTemplateCallable(
      const UpdateReplicationConfigurationTemplateRequestT& request) const {
    return SubmitCallable(&MgnClient::UpdateReplicationConfigurationTemplate, request);
  }
 
  template <typename UpdateReplicationConfigurationTemplateRequestT = Model::UpdateReplicationConfigurationTemplateRequest>
  void UpdateReplicationConfigurationTemplateAsync(const UpdateReplicationConfigurationTemplateRequestT& request,
                                                   const UpdateReplicationConfigurationTemplateResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::UpdateReplicationConfigurationTemplate, request, handler, context);
  }
 
  virtual Model::UpdateSourceServerOutcome UpdateSourceServer(const Model::UpdateSourceServerRequest& request) const;
 
  template <typename UpdateSourceServerRequestT = Model::UpdateSourceServerRequest>
  Model::UpdateSourceServerOutcomeCallable UpdateSourceServerCallable(const UpdateSourceServerRequestT& request) const {
    return SubmitCallable(&MgnClient::UpdateSourceServer, request);
  }
 
  template <typename UpdateSourceServerRequestT = Model::UpdateSourceServerRequest>
  void UpdateSourceServerAsync(const UpdateSourceServerRequestT& request, const UpdateSourceServerResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::UpdateSourceServer, request, handler, context);
  }
 
  virtual Model::UpdateSourceServerReplicationTypeOutcome UpdateSourceServerReplicationType(
      const Model::UpdateSourceServerReplicationTypeRequest& request) const;
 
  template <typename UpdateSourceServerReplicationTypeRequestT = Model::UpdateSourceServerReplicationTypeRequest>
  Model::UpdateSourceServerReplicationTypeOutcomeCallable UpdateSourceServerReplicationTypeCallable(
      const UpdateSourceServerReplicationTypeRequestT& request) const {
    return SubmitCallable(&MgnClient::UpdateSourceServerReplicationType, request);
  }
 
  template <typename UpdateSourceServerReplicationTypeRequestT = Model::UpdateSourceServerReplicationTypeRequest>
  void UpdateSourceServerReplicationTypeAsync(const UpdateSourceServerReplicationTypeRequestT& request,
                                              const UpdateSourceServerReplicationTypeResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::UpdateSourceServerReplicationType, request, handler, context);
  }
 
  virtual Model::UpdateWaveOutcome UpdateWave(const Model::UpdateWaveRequest& request) const;
 
  template <typename UpdateWaveRequestT = Model::UpdateWaveRequest>
  Model::UpdateWaveOutcomeCallable UpdateWaveCallable(const UpdateWaveRequestT& request) const {
    return SubmitCallable(&MgnClient::UpdateWave, request);
  }
 
  template <typename UpdateWaveRequestT = Model::UpdateWaveRequest>
  void UpdateWaveAsync(const UpdateWaveRequestT& request, const UpdateWaveResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MgnClient::UpdateWave, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<MgnEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<MgnClient>;
  void init(const MgnClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, MgnError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  MgnClientConfiguration m_clientConfiguration;
  std::shared_ptr<MgnEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace mgn
}  // namespace Aws