BackupGatewayClient.h

 
#pragma once
#include <aws/backup-gateway/BackupGatewayPaginationBase.h>
#include <aws/backup-gateway/BackupGatewayServiceClientModel.h>
#include <aws/backup-gateway/BackupGatewayWaiter.h>
#include <aws/backup-gateway/BackupGateway_EXPORTS.h>
#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>
 
namespace Aws {
namespace BackupGateway {
class AWS_BACKUPGATEWAY_API BackupGatewayClient : public Aws::Client::AWSJsonClient,
                                                  public Aws::Client::ClientWithAsyncTemplateMethods<BackupGatewayClient>,
                                                  public BackupGatewayPaginationBase<BackupGatewayClient>,
                                                  public BackupGatewayWaiter<BackupGatewayClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef BackupGatewayClientConfiguration ClientConfigurationType;
  typedef BackupGatewayEndpointProvider EndpointProviderType;
 
  BackupGatewayClient(const Aws::BackupGateway::BackupGatewayClientConfiguration& clientConfiguration =
                          Aws::BackupGateway::BackupGatewayClientConfiguration(),
                      std::shared_ptr<BackupGatewayEndpointProviderBase> endpointProvider = nullptr);
 
  BackupGatewayClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<BackupGatewayEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::BackupGateway::BackupGatewayClientConfiguration& clientConfiguration =
                          Aws::BackupGateway::BackupGatewayClientConfiguration());
 
  BackupGatewayClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<BackupGatewayEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::BackupGateway::BackupGatewayClientConfiguration& clientConfiguration =
                          Aws::BackupGateway::BackupGatewayClientConfiguration());
 
  /* Legacy constructors due deprecation */
  BackupGatewayClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  BackupGatewayClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  BackupGatewayClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~BackupGatewayClient();
 
  virtual Model::AssociateGatewayToServerOutcome AssociateGatewayToServer(const Model::AssociateGatewayToServerRequest& request) const;
 
  template <typename AssociateGatewayToServerRequestT = Model::AssociateGatewayToServerRequest>
  Model::AssociateGatewayToServerOutcomeCallable AssociateGatewayToServerCallable(const AssociateGatewayToServerRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::AssociateGatewayToServer, request);
  }
 
  template <typename AssociateGatewayToServerRequestT = Model::AssociateGatewayToServerRequest>
  void AssociateGatewayToServerAsync(const AssociateGatewayToServerRequestT& request,
                                     const AssociateGatewayToServerResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::AssociateGatewayToServer, request, handler, context);
  }
 
  virtual Model::CreateGatewayOutcome CreateGateway(const Model::CreateGatewayRequest& request) const;
 
  template <typename CreateGatewayRequestT = Model::CreateGatewayRequest>
  Model::CreateGatewayOutcomeCallable CreateGatewayCallable(const CreateGatewayRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::CreateGateway, request);
  }
 
  template <typename CreateGatewayRequestT = Model::CreateGatewayRequest>
  void CreateGatewayAsync(const CreateGatewayRequestT& request, const CreateGatewayResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::CreateGateway, request, handler, context);
  }
 
  virtual Model::DeleteGatewayOutcome DeleteGateway(const Model::DeleteGatewayRequest& request) const;
 
  template <typename DeleteGatewayRequestT = Model::DeleteGatewayRequest>
  Model::DeleteGatewayOutcomeCallable DeleteGatewayCallable(const DeleteGatewayRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::DeleteGateway, request);
  }
 
  template <typename DeleteGatewayRequestT = Model::DeleteGatewayRequest>
  void DeleteGatewayAsync(const DeleteGatewayRequestT& request, const DeleteGatewayResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::DeleteGateway, request, handler, context);
  }
 
  virtual Model::DeleteHypervisorOutcome DeleteHypervisor(const Model::DeleteHypervisorRequest& request) const;
 
  template <typename DeleteHypervisorRequestT = Model::DeleteHypervisorRequest>
  Model::DeleteHypervisorOutcomeCallable DeleteHypervisorCallable(const DeleteHypervisorRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::DeleteHypervisor, request);
  }
 
  template <typename DeleteHypervisorRequestT = Model::DeleteHypervisorRequest>
  void DeleteHypervisorAsync(const DeleteHypervisorRequestT& request, const DeleteHypervisorResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::DeleteHypervisor, request, handler, context);
  }
 
  virtual Model::DisassociateGatewayFromServerOutcome DisassociateGatewayFromServer(
      const Model::DisassociateGatewayFromServerRequest& request) const;
 
  template <typename DisassociateGatewayFromServerRequestT = Model::DisassociateGatewayFromServerRequest>
  Model::DisassociateGatewayFromServerOutcomeCallable DisassociateGatewayFromServerCallable(
      const DisassociateGatewayFromServerRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::DisassociateGatewayFromServer, request);
  }
 
  template <typename DisassociateGatewayFromServerRequestT = Model::DisassociateGatewayFromServerRequest>
  void DisassociateGatewayFromServerAsync(const DisassociateGatewayFromServerRequestT& request,
                                          const DisassociateGatewayFromServerResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::DisassociateGatewayFromServer, request, handler, context);
  }
 
  virtual Model::GetBandwidthRateLimitScheduleOutcome GetBandwidthRateLimitSchedule(
      const Model::GetBandwidthRateLimitScheduleRequest& request) const;
 
  template <typename GetBandwidthRateLimitScheduleRequestT = Model::GetBandwidthRateLimitScheduleRequest>
  Model::GetBandwidthRateLimitScheduleOutcomeCallable GetBandwidthRateLimitScheduleCallable(
      const GetBandwidthRateLimitScheduleRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::GetBandwidthRateLimitSchedule, request);
  }
 
  template <typename GetBandwidthRateLimitScheduleRequestT = Model::GetBandwidthRateLimitScheduleRequest>
  void GetBandwidthRateLimitScheduleAsync(const GetBandwidthRateLimitScheduleRequestT& request,
                                          const GetBandwidthRateLimitScheduleResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::GetBandwidthRateLimitSchedule, request, handler, context);
  }
 
  virtual Model::GetGatewayOutcome GetGateway(const Model::GetGatewayRequest& request) const;
 
  template <typename GetGatewayRequestT = Model::GetGatewayRequest>
  Model::GetGatewayOutcomeCallable GetGatewayCallable(const GetGatewayRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::GetGateway, request);
  }
 
  template <typename GetGatewayRequestT = Model::GetGatewayRequest>
  void GetGatewayAsync(const GetGatewayRequestT& request, const GetGatewayResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::GetGateway, request, handler, context);
  }
 
  virtual Model::GetHypervisorOutcome GetHypervisor(const Model::GetHypervisorRequest& request) const;
 
  template <typename GetHypervisorRequestT = Model::GetHypervisorRequest>
  Model::GetHypervisorOutcomeCallable GetHypervisorCallable(const GetHypervisorRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::GetHypervisor, request);
  }
 
  template <typename GetHypervisorRequestT = Model::GetHypervisorRequest>
  void GetHypervisorAsync(const GetHypervisorRequestT& request, const GetHypervisorResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::GetHypervisor, request, handler, context);
  }
 
  virtual Model::GetHypervisorPropertyMappingsOutcome GetHypervisorPropertyMappings(
      const Model::GetHypervisorPropertyMappingsRequest& request) const;
 
  template <typename GetHypervisorPropertyMappingsRequestT = Model::GetHypervisorPropertyMappingsRequest>
  Model::GetHypervisorPropertyMappingsOutcomeCallable GetHypervisorPropertyMappingsCallable(
      const GetHypervisorPropertyMappingsRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::GetHypervisorPropertyMappings, request);
  }
 
  template <typename GetHypervisorPropertyMappingsRequestT = Model::GetHypervisorPropertyMappingsRequest>
  void GetHypervisorPropertyMappingsAsync(const GetHypervisorPropertyMappingsRequestT& request,
                                          const GetHypervisorPropertyMappingsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::GetHypervisorPropertyMappings, request, handler, context);
  }
 
  virtual Model::GetVirtualMachineOutcome GetVirtualMachine(const Model::GetVirtualMachineRequest& request) const;
 
  template <typename GetVirtualMachineRequestT = Model::GetVirtualMachineRequest>
  Model::GetVirtualMachineOutcomeCallable GetVirtualMachineCallable(const GetVirtualMachineRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::GetVirtualMachine, request);
  }
 
  template <typename GetVirtualMachineRequestT = Model::GetVirtualMachineRequest>
  void GetVirtualMachineAsync(const GetVirtualMachineRequestT& request, const GetVirtualMachineResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::GetVirtualMachine, request, handler, context);
  }
 
  virtual Model::ImportHypervisorConfigurationOutcome ImportHypervisorConfiguration(
      const Model::ImportHypervisorConfigurationRequest& request) const;
 
  template <typename ImportHypervisorConfigurationRequestT = Model::ImportHypervisorConfigurationRequest>
  Model::ImportHypervisorConfigurationOutcomeCallable ImportHypervisorConfigurationCallable(
      const ImportHypervisorConfigurationRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::ImportHypervisorConfiguration, request);
  }
 
  template <typename ImportHypervisorConfigurationRequestT = Model::ImportHypervisorConfigurationRequest>
  void ImportHypervisorConfigurationAsync(const ImportHypervisorConfigurationRequestT& request,
                                          const ImportHypervisorConfigurationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::ImportHypervisorConfiguration, request, handler, context);
  }
 
  virtual Model::ListGatewaysOutcome ListGateways(const Model::ListGatewaysRequest& request = {}) const;
 
  template <typename ListGatewaysRequestT = Model::ListGatewaysRequest>
  Model::ListGatewaysOutcomeCallable ListGatewaysCallable(const ListGatewaysRequestT& request = {}) const {
    return SubmitCallable(&BackupGatewayClient::ListGateways, request);
  }
 
  template <typename ListGatewaysRequestT = Model::ListGatewaysRequest>
  void ListGatewaysAsync(const ListGatewaysResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListGatewaysRequestT& request = {}) const {
    return SubmitAsync(&BackupGatewayClient::ListGateways, request, handler, context);
  }
 
  virtual Model::ListHypervisorsOutcome ListHypervisors(const Model::ListHypervisorsRequest& request = {}) const;
 
  template <typename ListHypervisorsRequestT = Model::ListHypervisorsRequest>
  Model::ListHypervisorsOutcomeCallable ListHypervisorsCallable(const ListHypervisorsRequestT& request = {}) const {
    return SubmitCallable(&BackupGatewayClient::ListHypervisors, request);
  }
 
  template <typename ListHypervisorsRequestT = Model::ListHypervisorsRequest>
  void ListHypervisorsAsync(const ListHypervisorsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListHypervisorsRequestT& request = {}) const {
    return SubmitAsync(&BackupGatewayClient::ListHypervisors, 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(&BackupGatewayClient::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(&BackupGatewayClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListVirtualMachinesOutcome ListVirtualMachines(const Model::ListVirtualMachinesRequest& request = {}) const;
 
  template <typename ListVirtualMachinesRequestT = Model::ListVirtualMachinesRequest>
  Model::ListVirtualMachinesOutcomeCallable ListVirtualMachinesCallable(const ListVirtualMachinesRequestT& request = {}) const {
    return SubmitCallable(&BackupGatewayClient::ListVirtualMachines, request);
  }
 
  template <typename ListVirtualMachinesRequestT = Model::ListVirtualMachinesRequest>
  void ListVirtualMachinesAsync(const ListVirtualMachinesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListVirtualMachinesRequestT& request = {}) const {
    return SubmitAsync(&BackupGatewayClient::ListVirtualMachines, request, handler, context);
  }
 
  virtual Model::PutBandwidthRateLimitScheduleOutcome PutBandwidthRateLimitSchedule(
      const Model::PutBandwidthRateLimitScheduleRequest& request) const;
 
  template <typename PutBandwidthRateLimitScheduleRequestT = Model::PutBandwidthRateLimitScheduleRequest>
  Model::PutBandwidthRateLimitScheduleOutcomeCallable PutBandwidthRateLimitScheduleCallable(
      const PutBandwidthRateLimitScheduleRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::PutBandwidthRateLimitSchedule, request);
  }
 
  template <typename PutBandwidthRateLimitScheduleRequestT = Model::PutBandwidthRateLimitScheduleRequest>
  void PutBandwidthRateLimitScheduleAsync(const PutBandwidthRateLimitScheduleRequestT& request,
                                          const PutBandwidthRateLimitScheduleResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::PutBandwidthRateLimitSchedule, request, handler, context);
  }
 
  virtual Model::PutHypervisorPropertyMappingsOutcome PutHypervisorPropertyMappings(
      const Model::PutHypervisorPropertyMappingsRequest& request) const;
 
  template <typename PutHypervisorPropertyMappingsRequestT = Model::PutHypervisorPropertyMappingsRequest>
  Model::PutHypervisorPropertyMappingsOutcomeCallable PutHypervisorPropertyMappingsCallable(
      const PutHypervisorPropertyMappingsRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::PutHypervisorPropertyMappings, request);
  }
 
  template <typename PutHypervisorPropertyMappingsRequestT = Model::PutHypervisorPropertyMappingsRequest>
  void PutHypervisorPropertyMappingsAsync(const PutHypervisorPropertyMappingsRequestT& request,
                                          const PutHypervisorPropertyMappingsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::PutHypervisorPropertyMappings, request, handler, context);
  }
 
  virtual Model::PutMaintenanceStartTimeOutcome PutMaintenanceStartTime(const Model::PutMaintenanceStartTimeRequest& request) const;
 
  template <typename PutMaintenanceStartTimeRequestT = Model::PutMaintenanceStartTimeRequest>
  Model::PutMaintenanceStartTimeOutcomeCallable PutMaintenanceStartTimeCallable(const PutMaintenanceStartTimeRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::PutMaintenanceStartTime, request);
  }
 
  template <typename PutMaintenanceStartTimeRequestT = Model::PutMaintenanceStartTimeRequest>
  void PutMaintenanceStartTimeAsync(const PutMaintenanceStartTimeRequestT& request,
                                    const PutMaintenanceStartTimeResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::PutMaintenanceStartTime, request, handler, context);
  }
 
  virtual Model::StartVirtualMachinesMetadataSyncOutcome StartVirtualMachinesMetadataSync(
      const Model::StartVirtualMachinesMetadataSyncRequest& request) const;
 
  template <typename StartVirtualMachinesMetadataSyncRequestT = Model::StartVirtualMachinesMetadataSyncRequest>
  Model::StartVirtualMachinesMetadataSyncOutcomeCallable StartVirtualMachinesMetadataSyncCallable(
      const StartVirtualMachinesMetadataSyncRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::StartVirtualMachinesMetadataSync, request);
  }
 
  template <typename StartVirtualMachinesMetadataSyncRequestT = Model::StartVirtualMachinesMetadataSyncRequest>
  void StartVirtualMachinesMetadataSyncAsync(const StartVirtualMachinesMetadataSyncRequestT& request,
                                             const StartVirtualMachinesMetadataSyncResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::StartVirtualMachinesMetadataSync, 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(&BackupGatewayClient::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(&BackupGatewayClient::TagResource, request, handler, context);
  }
 
  virtual Model::TestHypervisorConfigurationOutcome TestHypervisorConfiguration(
      const Model::TestHypervisorConfigurationRequest& request) const;
 
  template <typename TestHypervisorConfigurationRequestT = Model::TestHypervisorConfigurationRequest>
  Model::TestHypervisorConfigurationOutcomeCallable TestHypervisorConfigurationCallable(
      const TestHypervisorConfigurationRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::TestHypervisorConfiguration, request);
  }
 
  template <typename TestHypervisorConfigurationRequestT = Model::TestHypervisorConfigurationRequest>
  void TestHypervisorConfigurationAsync(const TestHypervisorConfigurationRequestT& request,
                                        const TestHypervisorConfigurationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::TestHypervisorConfiguration, 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(&BackupGatewayClient::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(&BackupGatewayClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateGatewayInformationOutcome UpdateGatewayInformation(const Model::UpdateGatewayInformationRequest& request) const;
 
  template <typename UpdateGatewayInformationRequestT = Model::UpdateGatewayInformationRequest>
  Model::UpdateGatewayInformationOutcomeCallable UpdateGatewayInformationCallable(const UpdateGatewayInformationRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::UpdateGatewayInformation, request);
  }
 
  template <typename UpdateGatewayInformationRequestT = Model::UpdateGatewayInformationRequest>
  void UpdateGatewayInformationAsync(const UpdateGatewayInformationRequestT& request,
                                     const UpdateGatewayInformationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::UpdateGatewayInformation, request, handler, context);
  }
 
  virtual Model::UpdateGatewaySoftwareNowOutcome UpdateGatewaySoftwareNow(const Model::UpdateGatewaySoftwareNowRequest& request) const;
 
  template <typename UpdateGatewaySoftwareNowRequestT = Model::UpdateGatewaySoftwareNowRequest>
  Model::UpdateGatewaySoftwareNowOutcomeCallable UpdateGatewaySoftwareNowCallable(const UpdateGatewaySoftwareNowRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::UpdateGatewaySoftwareNow, request);
  }
 
  template <typename UpdateGatewaySoftwareNowRequestT = Model::UpdateGatewaySoftwareNowRequest>
  void UpdateGatewaySoftwareNowAsync(const UpdateGatewaySoftwareNowRequestT& request,
                                     const UpdateGatewaySoftwareNowResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::UpdateGatewaySoftwareNow, request, handler, context);
  }
 
  virtual Model::UpdateHypervisorOutcome UpdateHypervisor(const Model::UpdateHypervisorRequest& request) const;
 
  template <typename UpdateHypervisorRequestT = Model::UpdateHypervisorRequest>
  Model::UpdateHypervisorOutcomeCallable UpdateHypervisorCallable(const UpdateHypervisorRequestT& request) const {
    return SubmitCallable(&BackupGatewayClient::UpdateHypervisor, request);
  }
 
  template <typename UpdateHypervisorRequestT = Model::UpdateHypervisorRequest>
  void UpdateHypervisorAsync(const UpdateHypervisorRequestT& request, const UpdateHypervisorResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupGatewayClient::UpdateHypervisor, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<BackupGatewayEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<BackupGatewayClient>;
  void init(const BackupGatewayClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, BackupGatewayError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  BackupGatewayClientConfiguration m_clientConfiguration;
  std::shared_ptr<BackupGatewayEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace BackupGateway
}  // namespace Aws