MgnClient.h

 
#pragma once
#include <aws/mgn/Mgn_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/mgn/MgnServiceClientModel.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