DrsClient.h

 
#pragma once
#include <aws/drs/Drs_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/drs/DrsServiceClientModel.h>
 
namespace Aws
{
namespace drs
{
  class AWS_DRS_API DrsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<DrsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef DrsClientConfiguration ClientConfigurationType;
      typedef DrsEndpointProvider EndpointProviderType;
 
        DrsClient(const Aws::drs::DrsClientConfiguration& clientConfiguration = Aws::drs::DrsClientConfiguration(),
                  std::shared_ptr<DrsEndpointProviderBase> endpointProvider = nullptr);
 
        DrsClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<DrsEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::drs::DrsClientConfiguration& clientConfiguration = Aws::drs::DrsClientConfiguration());
 
        DrsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<DrsEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::drs::DrsClientConfiguration& clientConfiguration = Aws::drs::DrsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        DrsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        DrsClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        DrsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~DrsClient();
 
        virtual Model::AssociateSourceNetworkStackOutcome AssociateSourceNetworkStack(const Model::AssociateSourceNetworkStackRequest& request) const;
 
        template<typename AssociateSourceNetworkStackRequestT = Model::AssociateSourceNetworkStackRequest>
        Model::AssociateSourceNetworkStackOutcomeCallable AssociateSourceNetworkStackCallable(const AssociateSourceNetworkStackRequestT& request) const
        {
            return SubmitCallable(&DrsClient::AssociateSourceNetworkStack, request);
        }
 
        template<typename AssociateSourceNetworkStackRequestT = Model::AssociateSourceNetworkStackRequest>
        void AssociateSourceNetworkStackAsync(const AssociateSourceNetworkStackRequestT& request, const AssociateSourceNetworkStackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::AssociateSourceNetworkStack, request, handler, context);
        }
 
        virtual Model::CreateExtendedSourceServerOutcome CreateExtendedSourceServer(const Model::CreateExtendedSourceServerRequest& request) const;
 
        template<typename CreateExtendedSourceServerRequestT = Model::CreateExtendedSourceServerRequest>
        Model::CreateExtendedSourceServerOutcomeCallable CreateExtendedSourceServerCallable(const CreateExtendedSourceServerRequestT& request) const
        {
            return SubmitCallable(&DrsClient::CreateExtendedSourceServer, request);
        }
 
        template<typename CreateExtendedSourceServerRequestT = Model::CreateExtendedSourceServerRequest>
        void CreateExtendedSourceServerAsync(const CreateExtendedSourceServerRequestT& request, const CreateExtendedSourceServerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::CreateExtendedSourceServer, 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(&DrsClient::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(&DrsClient::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(&DrsClient::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(&DrsClient::CreateReplicationConfigurationTemplate, request, handler, context);
        }
 
        virtual Model::CreateSourceNetworkOutcome CreateSourceNetwork(const Model::CreateSourceNetworkRequest& request) const;
 
        template<typename CreateSourceNetworkRequestT = Model::CreateSourceNetworkRequest>
        Model::CreateSourceNetworkOutcomeCallable CreateSourceNetworkCallable(const CreateSourceNetworkRequestT& request) const
        {
            return SubmitCallable(&DrsClient::CreateSourceNetwork, request);
        }
 
        template<typename CreateSourceNetworkRequestT = Model::CreateSourceNetworkRequest>
        void CreateSourceNetworkAsync(const CreateSourceNetworkRequestT& request, const CreateSourceNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::CreateSourceNetwork, 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(&DrsClient::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(&DrsClient::DeleteJob, request, handler, context);
        }
 
        virtual Model::DeleteLaunchActionOutcome DeleteLaunchAction(const Model::DeleteLaunchActionRequest& request) const;
 
        template<typename DeleteLaunchActionRequestT = Model::DeleteLaunchActionRequest>
        Model::DeleteLaunchActionOutcomeCallable DeleteLaunchActionCallable(const DeleteLaunchActionRequestT& request) const
        {
            return SubmitCallable(&DrsClient::DeleteLaunchAction, request);
        }
 
        template<typename DeleteLaunchActionRequestT = Model::DeleteLaunchActionRequest>
        void DeleteLaunchActionAsync(const DeleteLaunchActionRequestT& request, const DeleteLaunchActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::DeleteLaunchAction, 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(&DrsClient::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(&DrsClient::DeleteLaunchConfigurationTemplate, request, handler, context);
        }
 
        virtual Model::DeleteRecoveryInstanceOutcome DeleteRecoveryInstance(const Model::DeleteRecoveryInstanceRequest& request) const;
 
        template<typename DeleteRecoveryInstanceRequestT = Model::DeleteRecoveryInstanceRequest>
        Model::DeleteRecoveryInstanceOutcomeCallable DeleteRecoveryInstanceCallable(const DeleteRecoveryInstanceRequestT& request) const
        {
            return SubmitCallable(&DrsClient::DeleteRecoveryInstance, request);
        }
 
        template<typename DeleteRecoveryInstanceRequestT = Model::DeleteRecoveryInstanceRequest>
        void DeleteRecoveryInstanceAsync(const DeleteRecoveryInstanceRequestT& request, const DeleteRecoveryInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::DeleteRecoveryInstance, 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(&DrsClient::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(&DrsClient::DeleteReplicationConfigurationTemplate, request, handler, context);
        }
 
        virtual Model::DeleteSourceNetworkOutcome DeleteSourceNetwork(const Model::DeleteSourceNetworkRequest& request) const;
 
        template<typename DeleteSourceNetworkRequestT = Model::DeleteSourceNetworkRequest>
        Model::DeleteSourceNetworkOutcomeCallable DeleteSourceNetworkCallable(const DeleteSourceNetworkRequestT& request) const
        {
            return SubmitCallable(&DrsClient::DeleteSourceNetwork, request);
        }
 
        template<typename DeleteSourceNetworkRequestT = Model::DeleteSourceNetworkRequest>
        void DeleteSourceNetworkAsync(const DeleteSourceNetworkRequestT& request, const DeleteSourceNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::DeleteSourceNetwork, 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(&DrsClient::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(&DrsClient::DeleteSourceServer, 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(&DrsClient::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(&DrsClient::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(&DrsClient::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(&DrsClient::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(&DrsClient::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(&DrsClient::DescribeLaunchConfigurationTemplates, request, handler, context);
        }
 
        virtual Model::DescribeRecoveryInstancesOutcome DescribeRecoveryInstances(const Model::DescribeRecoveryInstancesRequest& request = {}) const;
 
        template<typename DescribeRecoveryInstancesRequestT = Model::DescribeRecoveryInstancesRequest>
        Model::DescribeRecoveryInstancesOutcomeCallable DescribeRecoveryInstancesCallable(const DescribeRecoveryInstancesRequestT& request = {}) const
        {
            return SubmitCallable(&DrsClient::DescribeRecoveryInstances, request);
        }
 
        template<typename DescribeRecoveryInstancesRequestT = Model::DescribeRecoveryInstancesRequest>
        void DescribeRecoveryInstancesAsync(const DescribeRecoveryInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeRecoveryInstancesRequestT& request = {}) const
        {
            return SubmitAsync(&DrsClient::DescribeRecoveryInstances, request, handler, context);
        }
 
        virtual Model::DescribeRecoverySnapshotsOutcome DescribeRecoverySnapshots(const Model::DescribeRecoverySnapshotsRequest& request) const;
 
        template<typename DescribeRecoverySnapshotsRequestT = Model::DescribeRecoverySnapshotsRequest>
        Model::DescribeRecoverySnapshotsOutcomeCallable DescribeRecoverySnapshotsCallable(const DescribeRecoverySnapshotsRequestT& request) const
        {
            return SubmitCallable(&DrsClient::DescribeRecoverySnapshots, request);
        }
 
        template<typename DescribeRecoverySnapshotsRequestT = Model::DescribeRecoverySnapshotsRequest>
        void DescribeRecoverySnapshotsAsync(const DescribeRecoverySnapshotsRequestT& request, const DescribeRecoverySnapshotsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::DescribeRecoverySnapshots, 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(&DrsClient::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(&DrsClient::DescribeReplicationConfigurationTemplates, request, handler, context);
        }
 
        virtual Model::DescribeSourceNetworksOutcome DescribeSourceNetworks(const Model::DescribeSourceNetworksRequest& request = {}) const;
 
        template<typename DescribeSourceNetworksRequestT = Model::DescribeSourceNetworksRequest>
        Model::DescribeSourceNetworksOutcomeCallable DescribeSourceNetworksCallable(const DescribeSourceNetworksRequestT& request = {}) const
        {
            return SubmitCallable(&DrsClient::DescribeSourceNetworks, request);
        }
 
        template<typename DescribeSourceNetworksRequestT = Model::DescribeSourceNetworksRequest>
        void DescribeSourceNetworksAsync(const DescribeSourceNetworksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeSourceNetworksRequestT& request = {}) const
        {
            return SubmitAsync(&DrsClient::DescribeSourceNetworks, 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(&DrsClient::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(&DrsClient::DescribeSourceServers, request, handler, context);
        }
 
        virtual Model::DisconnectRecoveryInstanceOutcome DisconnectRecoveryInstance(const Model::DisconnectRecoveryInstanceRequest& request) const;
 
        template<typename DisconnectRecoveryInstanceRequestT = Model::DisconnectRecoveryInstanceRequest>
        Model::DisconnectRecoveryInstanceOutcomeCallable DisconnectRecoveryInstanceCallable(const DisconnectRecoveryInstanceRequestT& request) const
        {
            return SubmitCallable(&DrsClient::DisconnectRecoveryInstance, request);
        }
 
        template<typename DisconnectRecoveryInstanceRequestT = Model::DisconnectRecoveryInstanceRequest>
        void DisconnectRecoveryInstanceAsync(const DisconnectRecoveryInstanceRequestT& request, const DisconnectRecoveryInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::DisconnectRecoveryInstance, request, handler, context);
        }
 
        virtual Model::DisconnectSourceServerOutcome DisconnectSourceServer(const Model::DisconnectSourceServerRequest& request) const;
 
        template<typename DisconnectSourceServerRequestT = Model::DisconnectSourceServerRequest>
        Model::DisconnectSourceServerOutcomeCallable DisconnectSourceServerCallable(const DisconnectSourceServerRequestT& request) const
        {
            return SubmitCallable(&DrsClient::DisconnectSourceServer, request);
        }
 
        template<typename DisconnectSourceServerRequestT = Model::DisconnectSourceServerRequest>
        void DisconnectSourceServerAsync(const DisconnectSourceServerRequestT& request, const DisconnectSourceServerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::DisconnectSourceServer, request, handler, context);
        }
 
        virtual Model::ExportSourceNetworkCfnTemplateOutcome ExportSourceNetworkCfnTemplate(const Model::ExportSourceNetworkCfnTemplateRequest& request) const;
 
        template<typename ExportSourceNetworkCfnTemplateRequestT = Model::ExportSourceNetworkCfnTemplateRequest>
        Model::ExportSourceNetworkCfnTemplateOutcomeCallable ExportSourceNetworkCfnTemplateCallable(const ExportSourceNetworkCfnTemplateRequestT& request) const
        {
            return SubmitCallable(&DrsClient::ExportSourceNetworkCfnTemplate, request);
        }
 
        template<typename ExportSourceNetworkCfnTemplateRequestT = Model::ExportSourceNetworkCfnTemplateRequest>
        void ExportSourceNetworkCfnTemplateAsync(const ExportSourceNetworkCfnTemplateRequestT& request, const ExportSourceNetworkCfnTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::ExportSourceNetworkCfnTemplate, request, handler, context);
        }
 
        virtual Model::GetFailbackReplicationConfigurationOutcome GetFailbackReplicationConfiguration(const Model::GetFailbackReplicationConfigurationRequest& request) const;
 
        template<typename GetFailbackReplicationConfigurationRequestT = Model::GetFailbackReplicationConfigurationRequest>
        Model::GetFailbackReplicationConfigurationOutcomeCallable GetFailbackReplicationConfigurationCallable(const GetFailbackReplicationConfigurationRequestT& request) const
        {
            return SubmitCallable(&DrsClient::GetFailbackReplicationConfiguration, request);
        }
 
        template<typename GetFailbackReplicationConfigurationRequestT = Model::GetFailbackReplicationConfigurationRequest>
        void GetFailbackReplicationConfigurationAsync(const GetFailbackReplicationConfigurationRequestT& request, const GetFailbackReplicationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::GetFailbackReplicationConfiguration, 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(&DrsClient::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(&DrsClient::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(&DrsClient::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(&DrsClient::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(&DrsClient::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(&DrsClient::InitializeService, request, handler, context);
        }
 
        virtual Model::ListExtensibleSourceServersOutcome ListExtensibleSourceServers(const Model::ListExtensibleSourceServersRequest& request) const;
 
        template<typename ListExtensibleSourceServersRequestT = Model::ListExtensibleSourceServersRequest>
        Model::ListExtensibleSourceServersOutcomeCallable ListExtensibleSourceServersCallable(const ListExtensibleSourceServersRequestT& request) const
        {
            return SubmitCallable(&DrsClient::ListExtensibleSourceServers, request);
        }
 
        template<typename ListExtensibleSourceServersRequestT = Model::ListExtensibleSourceServersRequest>
        void ListExtensibleSourceServersAsync(const ListExtensibleSourceServersRequestT& request, const ListExtensibleSourceServersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::ListExtensibleSourceServers, request, handler, context);
        }
 
        virtual Model::ListLaunchActionsOutcome ListLaunchActions(const Model::ListLaunchActionsRequest& request) const;
 
        template<typename ListLaunchActionsRequestT = Model::ListLaunchActionsRequest>
        Model::ListLaunchActionsOutcomeCallable ListLaunchActionsCallable(const ListLaunchActionsRequestT& request) const
        {
            return SubmitCallable(&DrsClient::ListLaunchActions, request);
        }
 
        template<typename ListLaunchActionsRequestT = Model::ListLaunchActionsRequest>
        void ListLaunchActionsAsync(const ListLaunchActionsRequestT& request, const ListLaunchActionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::ListLaunchActions, request, handler, context);
        }
 
        virtual Model::ListStagingAccountsOutcome ListStagingAccounts(const Model::ListStagingAccountsRequest& request = {}) const;
 
        template<typename ListStagingAccountsRequestT = Model::ListStagingAccountsRequest>
        Model::ListStagingAccountsOutcomeCallable ListStagingAccountsCallable(const ListStagingAccountsRequestT& request = {}) const
        {
            return SubmitCallable(&DrsClient::ListStagingAccounts, request);
        }
 
        template<typename ListStagingAccountsRequestT = Model::ListStagingAccountsRequest>
        void ListStagingAccountsAsync(const ListStagingAccountsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListStagingAccountsRequestT& request = {}) const
        {
            return SubmitAsync(&DrsClient::ListStagingAccounts, 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(&DrsClient::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(&DrsClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutLaunchActionOutcome PutLaunchAction(const Model::PutLaunchActionRequest& request) const;
 
        template<typename PutLaunchActionRequestT = Model::PutLaunchActionRequest>
        Model::PutLaunchActionOutcomeCallable PutLaunchActionCallable(const PutLaunchActionRequestT& request) const
        {
            return SubmitCallable(&DrsClient::PutLaunchAction, request);
        }
 
        template<typename PutLaunchActionRequestT = Model::PutLaunchActionRequest>
        void PutLaunchActionAsync(const PutLaunchActionRequestT& request, const PutLaunchActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::PutLaunchAction, request, handler, context);
        }
 
        virtual Model::ReverseReplicationOutcome ReverseReplication(const Model::ReverseReplicationRequest& request) const;
 
        template<typename ReverseReplicationRequestT = Model::ReverseReplicationRequest>
        Model::ReverseReplicationOutcomeCallable ReverseReplicationCallable(const ReverseReplicationRequestT& request) const
        {
            return SubmitCallable(&DrsClient::ReverseReplication, request);
        }
 
        template<typename ReverseReplicationRequestT = Model::ReverseReplicationRequest>
        void ReverseReplicationAsync(const ReverseReplicationRequestT& request, const ReverseReplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::ReverseReplication, request, handler, context);
        }
 
        virtual Model::StartFailbackLaunchOutcome StartFailbackLaunch(const Model::StartFailbackLaunchRequest& request) const;
 
        template<typename StartFailbackLaunchRequestT = Model::StartFailbackLaunchRequest>
        Model::StartFailbackLaunchOutcomeCallable StartFailbackLaunchCallable(const StartFailbackLaunchRequestT& request) const
        {
            return SubmitCallable(&DrsClient::StartFailbackLaunch, request);
        }
 
        template<typename StartFailbackLaunchRequestT = Model::StartFailbackLaunchRequest>
        void StartFailbackLaunchAsync(const StartFailbackLaunchRequestT& request, const StartFailbackLaunchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::StartFailbackLaunch, request, handler, context);
        }
 
        virtual Model::StartRecoveryOutcome StartRecovery(const Model::StartRecoveryRequest& request) const;
 
        template<typename StartRecoveryRequestT = Model::StartRecoveryRequest>
        Model::StartRecoveryOutcomeCallable StartRecoveryCallable(const StartRecoveryRequestT& request) const
        {
            return SubmitCallable(&DrsClient::StartRecovery, request);
        }
 
        template<typename StartRecoveryRequestT = Model::StartRecoveryRequest>
        void StartRecoveryAsync(const StartRecoveryRequestT& request, const StartRecoveryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::StartRecovery, 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(&DrsClient::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(&DrsClient::StartReplication, request, handler, context);
        }
 
        virtual Model::StartSourceNetworkRecoveryOutcome StartSourceNetworkRecovery(const Model::StartSourceNetworkRecoveryRequest& request) const;
 
        template<typename StartSourceNetworkRecoveryRequestT = Model::StartSourceNetworkRecoveryRequest>
        Model::StartSourceNetworkRecoveryOutcomeCallable StartSourceNetworkRecoveryCallable(const StartSourceNetworkRecoveryRequestT& request) const
        {
            return SubmitCallable(&DrsClient::StartSourceNetworkRecovery, request);
        }
 
        template<typename StartSourceNetworkRecoveryRequestT = Model::StartSourceNetworkRecoveryRequest>
        void StartSourceNetworkRecoveryAsync(const StartSourceNetworkRecoveryRequestT& request, const StartSourceNetworkRecoveryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::StartSourceNetworkRecovery, request, handler, context);
        }
 
        virtual Model::StartSourceNetworkReplicationOutcome StartSourceNetworkReplication(const Model::StartSourceNetworkReplicationRequest& request) const;
 
        template<typename StartSourceNetworkReplicationRequestT = Model::StartSourceNetworkReplicationRequest>
        Model::StartSourceNetworkReplicationOutcomeCallable StartSourceNetworkReplicationCallable(const StartSourceNetworkReplicationRequestT& request) const
        {
            return SubmitCallable(&DrsClient::StartSourceNetworkReplication, request);
        }
 
        template<typename StartSourceNetworkReplicationRequestT = Model::StartSourceNetworkReplicationRequest>
        void StartSourceNetworkReplicationAsync(const StartSourceNetworkReplicationRequestT& request, const StartSourceNetworkReplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::StartSourceNetworkReplication, request, handler, context);
        }
 
        virtual Model::StopFailbackOutcome StopFailback(const Model::StopFailbackRequest& request) const;
 
        template<typename StopFailbackRequestT = Model::StopFailbackRequest>
        Model::StopFailbackOutcomeCallable StopFailbackCallable(const StopFailbackRequestT& request) const
        {
            return SubmitCallable(&DrsClient::StopFailback, request);
        }
 
        template<typename StopFailbackRequestT = Model::StopFailbackRequest>
        void StopFailbackAsync(const StopFailbackRequestT& request, const StopFailbackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::StopFailback, 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(&DrsClient::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(&DrsClient::StopReplication, request, handler, context);
        }
 
        virtual Model::StopSourceNetworkReplicationOutcome StopSourceNetworkReplication(const Model::StopSourceNetworkReplicationRequest& request) const;
 
        template<typename StopSourceNetworkReplicationRequestT = Model::StopSourceNetworkReplicationRequest>
        Model::StopSourceNetworkReplicationOutcomeCallable StopSourceNetworkReplicationCallable(const StopSourceNetworkReplicationRequestT& request) const
        {
            return SubmitCallable(&DrsClient::StopSourceNetworkReplication, request);
        }
 
        template<typename StopSourceNetworkReplicationRequestT = Model::StopSourceNetworkReplicationRequest>
        void StopSourceNetworkReplicationAsync(const StopSourceNetworkReplicationRequestT& request, const StopSourceNetworkReplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::StopSourceNetworkReplication, 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(&DrsClient::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(&DrsClient::TagResource, request, handler, context);
        }
 
        virtual Model::TerminateRecoveryInstancesOutcome TerminateRecoveryInstances(const Model::TerminateRecoveryInstancesRequest& request) const;
 
        template<typename TerminateRecoveryInstancesRequestT = Model::TerminateRecoveryInstancesRequest>
        Model::TerminateRecoveryInstancesOutcomeCallable TerminateRecoveryInstancesCallable(const TerminateRecoveryInstancesRequestT& request) const
        {
            return SubmitCallable(&DrsClient::TerminateRecoveryInstances, request);
        }
 
        template<typename TerminateRecoveryInstancesRequestT = Model::TerminateRecoveryInstancesRequest>
        void TerminateRecoveryInstancesAsync(const TerminateRecoveryInstancesRequestT& request, const TerminateRecoveryInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::TerminateRecoveryInstances, 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(&DrsClient::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(&DrsClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateFailbackReplicationConfigurationOutcome UpdateFailbackReplicationConfiguration(const Model::UpdateFailbackReplicationConfigurationRequest& request) const;
 
        template<typename UpdateFailbackReplicationConfigurationRequestT = Model::UpdateFailbackReplicationConfigurationRequest>
        Model::UpdateFailbackReplicationConfigurationOutcomeCallable UpdateFailbackReplicationConfigurationCallable(const UpdateFailbackReplicationConfigurationRequestT& request) const
        {
            return SubmitCallable(&DrsClient::UpdateFailbackReplicationConfiguration, request);
        }
 
        template<typename UpdateFailbackReplicationConfigurationRequestT = Model::UpdateFailbackReplicationConfigurationRequest>
        void UpdateFailbackReplicationConfigurationAsync(const UpdateFailbackReplicationConfigurationRequestT& request, const UpdateFailbackReplicationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DrsClient::UpdateFailbackReplicationConfiguration, 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(&DrsClient::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(&DrsClient::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(&DrsClient::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(&DrsClient::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(&DrsClient::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(&DrsClient::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(&DrsClient::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(&DrsClient::UpdateReplicationConfigurationTemplate, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<DrsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<DrsClient>;
      void init(const DrsClientConfiguration& clientConfiguration);
 
      DrsClientConfiguration m_clientConfiguration;
      std::shared_ptr<DrsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace drs
} // namespace Aws