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/MgnServiceClientModel.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:
  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::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::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::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::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::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::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::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);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<MgnEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<MgnClient>;
  void init(const MgnClientConfiguration& clientConfiguration);
 
  MgnClientConfiguration m_clientConfiguration;
  std::shared_ptr<MgnEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace mgn
}  // namespace Aws