BackupGatewayClient.h

 
#pragma once
#include <aws/backup-gateway/BackupGateway_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/backup-gateway/BackupGatewayServiceClientModel.h>
 
namespace Aws
{
namespace BackupGateway
{
  class AWS_BACKUPGATEWAY_API BackupGatewayClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<BackupGatewayEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<BackupGatewayClient>;
      void init(const BackupGatewayClientConfiguration& clientConfiguration);
 
      BackupGatewayClientConfiguration m_clientConfiguration;
      std::shared_ptr<BackupGatewayEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace BackupGateway
} // namespace Aws