DrsClient.h

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