BackupClient.h

 
#pragma once
#include <aws/backup/Backup_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/BackupServiceClientModel.h>
 
namespace Aws
{
namespace Backup
{
  class AWS_BACKUP_API BackupClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<BackupClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef BackupClientConfiguration ClientConfigurationType;
      typedef BackupEndpointProvider EndpointProviderType;
 
        BackupClient(const Aws::Backup::BackupClientConfiguration& clientConfiguration = Aws::Backup::BackupClientConfiguration(),
                     std::shared_ptr<BackupEndpointProviderBase> endpointProvider = nullptr);
 
        BackupClient(const Aws::Auth::AWSCredentials& credentials,
                     std::shared_ptr<BackupEndpointProviderBase> endpointProvider = nullptr,
                     const Aws::Backup::BackupClientConfiguration& clientConfiguration = Aws::Backup::BackupClientConfiguration());
 
        BackupClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     std::shared_ptr<BackupEndpointProviderBase> endpointProvider = nullptr,
                     const Aws::Backup::BackupClientConfiguration& clientConfiguration = Aws::Backup::BackupClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        BackupClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        BackupClient(const Aws::Auth::AWSCredentials& credentials,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        BackupClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~BackupClient();
 
        virtual Model::AssociateBackupVaultMpaApprovalTeamOutcome AssociateBackupVaultMpaApprovalTeam(const Model::AssociateBackupVaultMpaApprovalTeamRequest& request) const;
 
        template<typename AssociateBackupVaultMpaApprovalTeamRequestT = Model::AssociateBackupVaultMpaApprovalTeamRequest>
        Model::AssociateBackupVaultMpaApprovalTeamOutcomeCallable AssociateBackupVaultMpaApprovalTeamCallable(const AssociateBackupVaultMpaApprovalTeamRequestT& request) const
        {
            return SubmitCallable(&BackupClient::AssociateBackupVaultMpaApprovalTeam, request);
        }
 
        template<typename AssociateBackupVaultMpaApprovalTeamRequestT = Model::AssociateBackupVaultMpaApprovalTeamRequest>
        void AssociateBackupVaultMpaApprovalTeamAsync(const AssociateBackupVaultMpaApprovalTeamRequestT& request, const AssociateBackupVaultMpaApprovalTeamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::AssociateBackupVaultMpaApprovalTeam, request, handler, context);
        }
 
        virtual Model::CancelLegalHoldOutcome CancelLegalHold(const Model::CancelLegalHoldRequest& request) const;
 
        template<typename CancelLegalHoldRequestT = Model::CancelLegalHoldRequest>
        Model::CancelLegalHoldOutcomeCallable CancelLegalHoldCallable(const CancelLegalHoldRequestT& request) const
        {
            return SubmitCallable(&BackupClient::CancelLegalHold, request);
        }
 
        template<typename CancelLegalHoldRequestT = Model::CancelLegalHoldRequest>
        void CancelLegalHoldAsync(const CancelLegalHoldRequestT& request, const CancelLegalHoldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::CancelLegalHold, request, handler, context);
        }
 
        virtual Model::CreateBackupPlanOutcome CreateBackupPlan(const Model::CreateBackupPlanRequest& request) const;
 
        template<typename CreateBackupPlanRequestT = Model::CreateBackupPlanRequest>
        Model::CreateBackupPlanOutcomeCallable CreateBackupPlanCallable(const CreateBackupPlanRequestT& request) const
        {
            return SubmitCallable(&BackupClient::CreateBackupPlan, request);
        }
 
        template<typename CreateBackupPlanRequestT = Model::CreateBackupPlanRequest>
        void CreateBackupPlanAsync(const CreateBackupPlanRequestT& request, const CreateBackupPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::CreateBackupPlan, request, handler, context);
        }
 
        virtual Model::CreateBackupSelectionOutcome CreateBackupSelection(const Model::CreateBackupSelectionRequest& request) const;
 
        template<typename CreateBackupSelectionRequestT = Model::CreateBackupSelectionRequest>
        Model::CreateBackupSelectionOutcomeCallable CreateBackupSelectionCallable(const CreateBackupSelectionRequestT& request) const
        {
            return SubmitCallable(&BackupClient::CreateBackupSelection, request);
        }
 
        template<typename CreateBackupSelectionRequestT = Model::CreateBackupSelectionRequest>
        void CreateBackupSelectionAsync(const CreateBackupSelectionRequestT& request, const CreateBackupSelectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::CreateBackupSelection, request, handler, context);
        }
 
        virtual Model::CreateBackupVaultOutcome CreateBackupVault(const Model::CreateBackupVaultRequest& request) const;
 
        template<typename CreateBackupVaultRequestT = Model::CreateBackupVaultRequest>
        Model::CreateBackupVaultOutcomeCallable CreateBackupVaultCallable(const CreateBackupVaultRequestT& request) const
        {
            return SubmitCallable(&BackupClient::CreateBackupVault, request);
        }
 
        template<typename CreateBackupVaultRequestT = Model::CreateBackupVaultRequest>
        void CreateBackupVaultAsync(const CreateBackupVaultRequestT& request, const CreateBackupVaultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::CreateBackupVault, request, handler, context);
        }
 
        virtual Model::CreateFrameworkOutcome CreateFramework(const Model::CreateFrameworkRequest& request) const;
 
        template<typename CreateFrameworkRequestT = Model::CreateFrameworkRequest>
        Model::CreateFrameworkOutcomeCallable CreateFrameworkCallable(const CreateFrameworkRequestT& request) const
        {
            return SubmitCallable(&BackupClient::CreateFramework, request);
        }
 
        template<typename CreateFrameworkRequestT = Model::CreateFrameworkRequest>
        void CreateFrameworkAsync(const CreateFrameworkRequestT& request, const CreateFrameworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::CreateFramework, request, handler, context);
        }
 
        virtual Model::CreateLegalHoldOutcome CreateLegalHold(const Model::CreateLegalHoldRequest& request) const;
 
        template<typename CreateLegalHoldRequestT = Model::CreateLegalHoldRequest>
        Model::CreateLegalHoldOutcomeCallable CreateLegalHoldCallable(const CreateLegalHoldRequestT& request) const
        {
            return SubmitCallable(&BackupClient::CreateLegalHold, request);
        }
 
        template<typename CreateLegalHoldRequestT = Model::CreateLegalHoldRequest>
        void CreateLegalHoldAsync(const CreateLegalHoldRequestT& request, const CreateLegalHoldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::CreateLegalHold, request, handler, context);
        }
 
        virtual Model::CreateLogicallyAirGappedBackupVaultOutcome CreateLogicallyAirGappedBackupVault(const Model::CreateLogicallyAirGappedBackupVaultRequest& request) const;
 
        template<typename CreateLogicallyAirGappedBackupVaultRequestT = Model::CreateLogicallyAirGappedBackupVaultRequest>
        Model::CreateLogicallyAirGappedBackupVaultOutcomeCallable CreateLogicallyAirGappedBackupVaultCallable(const CreateLogicallyAirGappedBackupVaultRequestT& request) const
        {
            return SubmitCallable(&BackupClient::CreateLogicallyAirGappedBackupVault, request);
        }
 
        template<typename CreateLogicallyAirGappedBackupVaultRequestT = Model::CreateLogicallyAirGappedBackupVaultRequest>
        void CreateLogicallyAirGappedBackupVaultAsync(const CreateLogicallyAirGappedBackupVaultRequestT& request, const CreateLogicallyAirGappedBackupVaultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::CreateLogicallyAirGappedBackupVault, request, handler, context);
        }
 
        virtual Model::CreateReportPlanOutcome CreateReportPlan(const Model::CreateReportPlanRequest& request) const;
 
        template<typename CreateReportPlanRequestT = Model::CreateReportPlanRequest>
        Model::CreateReportPlanOutcomeCallable CreateReportPlanCallable(const CreateReportPlanRequestT& request) const
        {
            return SubmitCallable(&BackupClient::CreateReportPlan, request);
        }
 
        template<typename CreateReportPlanRequestT = Model::CreateReportPlanRequest>
        void CreateReportPlanAsync(const CreateReportPlanRequestT& request, const CreateReportPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::CreateReportPlan, request, handler, context);
        }
 
        virtual Model::CreateRestoreAccessBackupVaultOutcome CreateRestoreAccessBackupVault(const Model::CreateRestoreAccessBackupVaultRequest& request) const;
 
        template<typename CreateRestoreAccessBackupVaultRequestT = Model::CreateRestoreAccessBackupVaultRequest>
        Model::CreateRestoreAccessBackupVaultOutcomeCallable CreateRestoreAccessBackupVaultCallable(const CreateRestoreAccessBackupVaultRequestT& request) const
        {
            return SubmitCallable(&BackupClient::CreateRestoreAccessBackupVault, request);
        }
 
        template<typename CreateRestoreAccessBackupVaultRequestT = Model::CreateRestoreAccessBackupVaultRequest>
        void CreateRestoreAccessBackupVaultAsync(const CreateRestoreAccessBackupVaultRequestT& request, const CreateRestoreAccessBackupVaultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::CreateRestoreAccessBackupVault, request, handler, context);
        }
 
        virtual Model::CreateRestoreTestingPlanOutcome CreateRestoreTestingPlan(const Model::CreateRestoreTestingPlanRequest& request) const;
 
        template<typename CreateRestoreTestingPlanRequestT = Model::CreateRestoreTestingPlanRequest>
        Model::CreateRestoreTestingPlanOutcomeCallable CreateRestoreTestingPlanCallable(const CreateRestoreTestingPlanRequestT& request) const
        {
            return SubmitCallable(&BackupClient::CreateRestoreTestingPlan, request);
        }
 
        template<typename CreateRestoreTestingPlanRequestT = Model::CreateRestoreTestingPlanRequest>
        void CreateRestoreTestingPlanAsync(const CreateRestoreTestingPlanRequestT& request, const CreateRestoreTestingPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::CreateRestoreTestingPlan, request, handler, context);
        }
 
        virtual Model::CreateRestoreTestingSelectionOutcome CreateRestoreTestingSelection(const Model::CreateRestoreTestingSelectionRequest& request) const;
 
        template<typename CreateRestoreTestingSelectionRequestT = Model::CreateRestoreTestingSelectionRequest>
        Model::CreateRestoreTestingSelectionOutcomeCallable CreateRestoreTestingSelectionCallable(const CreateRestoreTestingSelectionRequestT& request) const
        {
            return SubmitCallable(&BackupClient::CreateRestoreTestingSelection, request);
        }
 
        template<typename CreateRestoreTestingSelectionRequestT = Model::CreateRestoreTestingSelectionRequest>
        void CreateRestoreTestingSelectionAsync(const CreateRestoreTestingSelectionRequestT& request, const CreateRestoreTestingSelectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::CreateRestoreTestingSelection, request, handler, context);
        }
 
        virtual Model::DeleteBackupPlanOutcome DeleteBackupPlan(const Model::DeleteBackupPlanRequest& request) const;
 
        template<typename DeleteBackupPlanRequestT = Model::DeleteBackupPlanRequest>
        Model::DeleteBackupPlanOutcomeCallable DeleteBackupPlanCallable(const DeleteBackupPlanRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DeleteBackupPlan, request);
        }
 
        template<typename DeleteBackupPlanRequestT = Model::DeleteBackupPlanRequest>
        void DeleteBackupPlanAsync(const DeleteBackupPlanRequestT& request, const DeleteBackupPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DeleteBackupPlan, request, handler, context);
        }
 
        virtual Model::DeleteBackupSelectionOutcome DeleteBackupSelection(const Model::DeleteBackupSelectionRequest& request) const;
 
        template<typename DeleteBackupSelectionRequestT = Model::DeleteBackupSelectionRequest>
        Model::DeleteBackupSelectionOutcomeCallable DeleteBackupSelectionCallable(const DeleteBackupSelectionRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DeleteBackupSelection, request);
        }
 
        template<typename DeleteBackupSelectionRequestT = Model::DeleteBackupSelectionRequest>
        void DeleteBackupSelectionAsync(const DeleteBackupSelectionRequestT& request, const DeleteBackupSelectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DeleteBackupSelection, request, handler, context);
        }
 
        virtual Model::DeleteBackupVaultOutcome DeleteBackupVault(const Model::DeleteBackupVaultRequest& request) const;
 
        template<typename DeleteBackupVaultRequestT = Model::DeleteBackupVaultRequest>
        Model::DeleteBackupVaultOutcomeCallable DeleteBackupVaultCallable(const DeleteBackupVaultRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DeleteBackupVault, request);
        }
 
        template<typename DeleteBackupVaultRequestT = Model::DeleteBackupVaultRequest>
        void DeleteBackupVaultAsync(const DeleteBackupVaultRequestT& request, const DeleteBackupVaultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DeleteBackupVault, request, handler, context);
        }
 
        virtual Model::DeleteBackupVaultAccessPolicyOutcome DeleteBackupVaultAccessPolicy(const Model::DeleteBackupVaultAccessPolicyRequest& request) const;
 
        template<typename DeleteBackupVaultAccessPolicyRequestT = Model::DeleteBackupVaultAccessPolicyRequest>
        Model::DeleteBackupVaultAccessPolicyOutcomeCallable DeleteBackupVaultAccessPolicyCallable(const DeleteBackupVaultAccessPolicyRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DeleteBackupVaultAccessPolicy, request);
        }
 
        template<typename DeleteBackupVaultAccessPolicyRequestT = Model::DeleteBackupVaultAccessPolicyRequest>
        void DeleteBackupVaultAccessPolicyAsync(const DeleteBackupVaultAccessPolicyRequestT& request, const DeleteBackupVaultAccessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DeleteBackupVaultAccessPolicy, request, handler, context);
        }
 
        virtual Model::DeleteBackupVaultLockConfigurationOutcome DeleteBackupVaultLockConfiguration(const Model::DeleteBackupVaultLockConfigurationRequest& request) const;
 
        template<typename DeleteBackupVaultLockConfigurationRequestT = Model::DeleteBackupVaultLockConfigurationRequest>
        Model::DeleteBackupVaultLockConfigurationOutcomeCallable DeleteBackupVaultLockConfigurationCallable(const DeleteBackupVaultLockConfigurationRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DeleteBackupVaultLockConfiguration, request);
        }
 
        template<typename DeleteBackupVaultLockConfigurationRequestT = Model::DeleteBackupVaultLockConfigurationRequest>
        void DeleteBackupVaultLockConfigurationAsync(const DeleteBackupVaultLockConfigurationRequestT& request, const DeleteBackupVaultLockConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DeleteBackupVaultLockConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteBackupVaultNotificationsOutcome DeleteBackupVaultNotifications(const Model::DeleteBackupVaultNotificationsRequest& request) const;
 
        template<typename DeleteBackupVaultNotificationsRequestT = Model::DeleteBackupVaultNotificationsRequest>
        Model::DeleteBackupVaultNotificationsOutcomeCallable DeleteBackupVaultNotificationsCallable(const DeleteBackupVaultNotificationsRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DeleteBackupVaultNotifications, request);
        }
 
        template<typename DeleteBackupVaultNotificationsRequestT = Model::DeleteBackupVaultNotificationsRequest>
        void DeleteBackupVaultNotificationsAsync(const DeleteBackupVaultNotificationsRequestT& request, const DeleteBackupVaultNotificationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DeleteBackupVaultNotifications, request, handler, context);
        }
 
        virtual Model::DeleteFrameworkOutcome DeleteFramework(const Model::DeleteFrameworkRequest& request) const;
 
        template<typename DeleteFrameworkRequestT = Model::DeleteFrameworkRequest>
        Model::DeleteFrameworkOutcomeCallable DeleteFrameworkCallable(const DeleteFrameworkRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DeleteFramework, request);
        }
 
        template<typename DeleteFrameworkRequestT = Model::DeleteFrameworkRequest>
        void DeleteFrameworkAsync(const DeleteFrameworkRequestT& request, const DeleteFrameworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DeleteFramework, request, handler, context);
        }
 
        virtual Model::DeleteRecoveryPointOutcome DeleteRecoveryPoint(const Model::DeleteRecoveryPointRequest& request) const;
 
        template<typename DeleteRecoveryPointRequestT = Model::DeleteRecoveryPointRequest>
        Model::DeleteRecoveryPointOutcomeCallable DeleteRecoveryPointCallable(const DeleteRecoveryPointRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DeleteRecoveryPoint, request);
        }
 
        template<typename DeleteRecoveryPointRequestT = Model::DeleteRecoveryPointRequest>
        void DeleteRecoveryPointAsync(const DeleteRecoveryPointRequestT& request, const DeleteRecoveryPointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DeleteRecoveryPoint, request, handler, context);
        }
 
        virtual Model::DeleteReportPlanOutcome DeleteReportPlan(const Model::DeleteReportPlanRequest& request) const;
 
        template<typename DeleteReportPlanRequestT = Model::DeleteReportPlanRequest>
        Model::DeleteReportPlanOutcomeCallable DeleteReportPlanCallable(const DeleteReportPlanRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DeleteReportPlan, request);
        }
 
        template<typename DeleteReportPlanRequestT = Model::DeleteReportPlanRequest>
        void DeleteReportPlanAsync(const DeleteReportPlanRequestT& request, const DeleteReportPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DeleteReportPlan, request, handler, context);
        }
 
        virtual Model::DeleteRestoreTestingPlanOutcome DeleteRestoreTestingPlan(const Model::DeleteRestoreTestingPlanRequest& request) const;
 
        template<typename DeleteRestoreTestingPlanRequestT = Model::DeleteRestoreTestingPlanRequest>
        Model::DeleteRestoreTestingPlanOutcomeCallable DeleteRestoreTestingPlanCallable(const DeleteRestoreTestingPlanRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DeleteRestoreTestingPlan, request);
        }
 
        template<typename DeleteRestoreTestingPlanRequestT = Model::DeleteRestoreTestingPlanRequest>
        void DeleteRestoreTestingPlanAsync(const DeleteRestoreTestingPlanRequestT& request, const DeleteRestoreTestingPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DeleteRestoreTestingPlan, request, handler, context);
        }
 
        virtual Model::DeleteRestoreTestingSelectionOutcome DeleteRestoreTestingSelection(const Model::DeleteRestoreTestingSelectionRequest& request) const;
 
        template<typename DeleteRestoreTestingSelectionRequestT = Model::DeleteRestoreTestingSelectionRequest>
        Model::DeleteRestoreTestingSelectionOutcomeCallable DeleteRestoreTestingSelectionCallable(const DeleteRestoreTestingSelectionRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DeleteRestoreTestingSelection, request);
        }
 
        template<typename DeleteRestoreTestingSelectionRequestT = Model::DeleteRestoreTestingSelectionRequest>
        void DeleteRestoreTestingSelectionAsync(const DeleteRestoreTestingSelectionRequestT& request, const DeleteRestoreTestingSelectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DeleteRestoreTestingSelection, request, handler, context);
        }
 
        virtual Model::DescribeBackupJobOutcome DescribeBackupJob(const Model::DescribeBackupJobRequest& request) const;
 
        template<typename DescribeBackupJobRequestT = Model::DescribeBackupJobRequest>
        Model::DescribeBackupJobOutcomeCallable DescribeBackupJobCallable(const DescribeBackupJobRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DescribeBackupJob, request);
        }
 
        template<typename DescribeBackupJobRequestT = Model::DescribeBackupJobRequest>
        void DescribeBackupJobAsync(const DescribeBackupJobRequestT& request, const DescribeBackupJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DescribeBackupJob, request, handler, context);
        }
 
        virtual Model::DescribeBackupVaultOutcome DescribeBackupVault(const Model::DescribeBackupVaultRequest& request) const;
 
        template<typename DescribeBackupVaultRequestT = Model::DescribeBackupVaultRequest>
        Model::DescribeBackupVaultOutcomeCallable DescribeBackupVaultCallable(const DescribeBackupVaultRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DescribeBackupVault, request);
        }
 
        template<typename DescribeBackupVaultRequestT = Model::DescribeBackupVaultRequest>
        void DescribeBackupVaultAsync(const DescribeBackupVaultRequestT& request, const DescribeBackupVaultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DescribeBackupVault, request, handler, context);
        }
 
        virtual Model::DescribeCopyJobOutcome DescribeCopyJob(const Model::DescribeCopyJobRequest& request) const;
 
        template<typename DescribeCopyJobRequestT = Model::DescribeCopyJobRequest>
        Model::DescribeCopyJobOutcomeCallable DescribeCopyJobCallable(const DescribeCopyJobRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DescribeCopyJob, request);
        }
 
        template<typename DescribeCopyJobRequestT = Model::DescribeCopyJobRequest>
        void DescribeCopyJobAsync(const DescribeCopyJobRequestT& request, const DescribeCopyJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DescribeCopyJob, request, handler, context);
        }
 
        virtual Model::DescribeFrameworkOutcome DescribeFramework(const Model::DescribeFrameworkRequest& request) const;
 
        template<typename DescribeFrameworkRequestT = Model::DescribeFrameworkRequest>
        Model::DescribeFrameworkOutcomeCallable DescribeFrameworkCallable(const DescribeFrameworkRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DescribeFramework, request);
        }
 
        template<typename DescribeFrameworkRequestT = Model::DescribeFrameworkRequest>
        void DescribeFrameworkAsync(const DescribeFrameworkRequestT& request, const DescribeFrameworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DescribeFramework, request, handler, context);
        }
 
        virtual Model::DescribeGlobalSettingsOutcome DescribeGlobalSettings(const Model::DescribeGlobalSettingsRequest& request = {}) const;
 
        template<typename DescribeGlobalSettingsRequestT = Model::DescribeGlobalSettingsRequest>
        Model::DescribeGlobalSettingsOutcomeCallable DescribeGlobalSettingsCallable(const DescribeGlobalSettingsRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::DescribeGlobalSettings, request);
        }
 
        template<typename DescribeGlobalSettingsRequestT = Model::DescribeGlobalSettingsRequest>
        void DescribeGlobalSettingsAsync(const DescribeGlobalSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeGlobalSettingsRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::DescribeGlobalSettings, request, handler, context);
        }
 
        virtual Model::DescribeProtectedResourceOutcome DescribeProtectedResource(const Model::DescribeProtectedResourceRequest& request) const;
 
        template<typename DescribeProtectedResourceRequestT = Model::DescribeProtectedResourceRequest>
        Model::DescribeProtectedResourceOutcomeCallable DescribeProtectedResourceCallable(const DescribeProtectedResourceRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DescribeProtectedResource, request);
        }
 
        template<typename DescribeProtectedResourceRequestT = Model::DescribeProtectedResourceRequest>
        void DescribeProtectedResourceAsync(const DescribeProtectedResourceRequestT& request, const DescribeProtectedResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DescribeProtectedResource, request, handler, context);
        }
 
        virtual Model::DescribeRecoveryPointOutcome DescribeRecoveryPoint(const Model::DescribeRecoveryPointRequest& request) const;
 
        template<typename DescribeRecoveryPointRequestT = Model::DescribeRecoveryPointRequest>
        Model::DescribeRecoveryPointOutcomeCallable DescribeRecoveryPointCallable(const DescribeRecoveryPointRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DescribeRecoveryPoint, request);
        }
 
        template<typename DescribeRecoveryPointRequestT = Model::DescribeRecoveryPointRequest>
        void DescribeRecoveryPointAsync(const DescribeRecoveryPointRequestT& request, const DescribeRecoveryPointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DescribeRecoveryPoint, request, handler, context);
        }
 
        virtual Model::DescribeRegionSettingsOutcome DescribeRegionSettings(const Model::DescribeRegionSettingsRequest& request = {}) const;
 
        template<typename DescribeRegionSettingsRequestT = Model::DescribeRegionSettingsRequest>
        Model::DescribeRegionSettingsOutcomeCallable DescribeRegionSettingsCallable(const DescribeRegionSettingsRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::DescribeRegionSettings, request);
        }
 
        template<typename DescribeRegionSettingsRequestT = Model::DescribeRegionSettingsRequest>
        void DescribeRegionSettingsAsync(const DescribeRegionSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeRegionSettingsRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::DescribeRegionSettings, request, handler, context);
        }
 
        virtual Model::DescribeReportJobOutcome DescribeReportJob(const Model::DescribeReportJobRequest& request) const;
 
        template<typename DescribeReportJobRequestT = Model::DescribeReportJobRequest>
        Model::DescribeReportJobOutcomeCallable DescribeReportJobCallable(const DescribeReportJobRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DescribeReportJob, request);
        }
 
        template<typename DescribeReportJobRequestT = Model::DescribeReportJobRequest>
        void DescribeReportJobAsync(const DescribeReportJobRequestT& request, const DescribeReportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DescribeReportJob, request, handler, context);
        }
 
        virtual Model::DescribeReportPlanOutcome DescribeReportPlan(const Model::DescribeReportPlanRequest& request) const;
 
        template<typename DescribeReportPlanRequestT = Model::DescribeReportPlanRequest>
        Model::DescribeReportPlanOutcomeCallable DescribeReportPlanCallable(const DescribeReportPlanRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DescribeReportPlan, request);
        }
 
        template<typename DescribeReportPlanRequestT = Model::DescribeReportPlanRequest>
        void DescribeReportPlanAsync(const DescribeReportPlanRequestT& request, const DescribeReportPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DescribeReportPlan, request, handler, context);
        }
 
        virtual Model::DescribeRestoreJobOutcome DescribeRestoreJob(const Model::DescribeRestoreJobRequest& request) const;
 
        template<typename DescribeRestoreJobRequestT = Model::DescribeRestoreJobRequest>
        Model::DescribeRestoreJobOutcomeCallable DescribeRestoreJobCallable(const DescribeRestoreJobRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DescribeRestoreJob, request);
        }
 
        template<typename DescribeRestoreJobRequestT = Model::DescribeRestoreJobRequest>
        void DescribeRestoreJobAsync(const DescribeRestoreJobRequestT& request, const DescribeRestoreJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DescribeRestoreJob, request, handler, context);
        }
 
        virtual Model::DisassociateBackupVaultMpaApprovalTeamOutcome DisassociateBackupVaultMpaApprovalTeam(const Model::DisassociateBackupVaultMpaApprovalTeamRequest& request) const;
 
        template<typename DisassociateBackupVaultMpaApprovalTeamRequestT = Model::DisassociateBackupVaultMpaApprovalTeamRequest>
        Model::DisassociateBackupVaultMpaApprovalTeamOutcomeCallable DisassociateBackupVaultMpaApprovalTeamCallable(const DisassociateBackupVaultMpaApprovalTeamRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DisassociateBackupVaultMpaApprovalTeam, request);
        }
 
        template<typename DisassociateBackupVaultMpaApprovalTeamRequestT = Model::DisassociateBackupVaultMpaApprovalTeamRequest>
        void DisassociateBackupVaultMpaApprovalTeamAsync(const DisassociateBackupVaultMpaApprovalTeamRequestT& request, const DisassociateBackupVaultMpaApprovalTeamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DisassociateBackupVaultMpaApprovalTeam, request, handler, context);
        }
 
        virtual Model::DisassociateRecoveryPointOutcome DisassociateRecoveryPoint(const Model::DisassociateRecoveryPointRequest& request) const;
 
        template<typename DisassociateRecoveryPointRequestT = Model::DisassociateRecoveryPointRequest>
        Model::DisassociateRecoveryPointOutcomeCallable DisassociateRecoveryPointCallable(const DisassociateRecoveryPointRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DisassociateRecoveryPoint, request);
        }
 
        template<typename DisassociateRecoveryPointRequestT = Model::DisassociateRecoveryPointRequest>
        void DisassociateRecoveryPointAsync(const DisassociateRecoveryPointRequestT& request, const DisassociateRecoveryPointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DisassociateRecoveryPoint, request, handler, context);
        }
 
        virtual Model::DisassociateRecoveryPointFromParentOutcome DisassociateRecoveryPointFromParent(const Model::DisassociateRecoveryPointFromParentRequest& request) const;
 
        template<typename DisassociateRecoveryPointFromParentRequestT = Model::DisassociateRecoveryPointFromParentRequest>
        Model::DisassociateRecoveryPointFromParentOutcomeCallable DisassociateRecoveryPointFromParentCallable(const DisassociateRecoveryPointFromParentRequestT& request) const
        {
            return SubmitCallable(&BackupClient::DisassociateRecoveryPointFromParent, request);
        }
 
        template<typename DisassociateRecoveryPointFromParentRequestT = Model::DisassociateRecoveryPointFromParentRequest>
        void DisassociateRecoveryPointFromParentAsync(const DisassociateRecoveryPointFromParentRequestT& request, const DisassociateRecoveryPointFromParentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::DisassociateRecoveryPointFromParent, request, handler, context);
        }
 
        virtual Model::ExportBackupPlanTemplateOutcome ExportBackupPlanTemplate(const Model::ExportBackupPlanTemplateRequest& request) const;
 
        template<typename ExportBackupPlanTemplateRequestT = Model::ExportBackupPlanTemplateRequest>
        Model::ExportBackupPlanTemplateOutcomeCallable ExportBackupPlanTemplateCallable(const ExportBackupPlanTemplateRequestT& request) const
        {
            return SubmitCallable(&BackupClient::ExportBackupPlanTemplate, request);
        }
 
        template<typename ExportBackupPlanTemplateRequestT = Model::ExportBackupPlanTemplateRequest>
        void ExportBackupPlanTemplateAsync(const ExportBackupPlanTemplateRequestT& request, const ExportBackupPlanTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::ExportBackupPlanTemplate, request, handler, context);
        }
 
        virtual Model::GetBackupPlanOutcome GetBackupPlan(const Model::GetBackupPlanRequest& request) const;
 
        template<typename GetBackupPlanRequestT = Model::GetBackupPlanRequest>
        Model::GetBackupPlanOutcomeCallable GetBackupPlanCallable(const GetBackupPlanRequestT& request) const
        {
            return SubmitCallable(&BackupClient::GetBackupPlan, request);
        }
 
        template<typename GetBackupPlanRequestT = Model::GetBackupPlanRequest>
        void GetBackupPlanAsync(const GetBackupPlanRequestT& request, const GetBackupPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::GetBackupPlan, request, handler, context);
        }
 
        virtual Model::GetBackupPlanFromJSONOutcome GetBackupPlanFromJSON(const Model::GetBackupPlanFromJSONRequest& request) const;
 
        template<typename GetBackupPlanFromJSONRequestT = Model::GetBackupPlanFromJSONRequest>
        Model::GetBackupPlanFromJSONOutcomeCallable GetBackupPlanFromJSONCallable(const GetBackupPlanFromJSONRequestT& request) const
        {
            return SubmitCallable(&BackupClient::GetBackupPlanFromJSON, request);
        }
 
        template<typename GetBackupPlanFromJSONRequestT = Model::GetBackupPlanFromJSONRequest>
        void GetBackupPlanFromJSONAsync(const GetBackupPlanFromJSONRequestT& request, const GetBackupPlanFromJSONResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::GetBackupPlanFromJSON, request, handler, context);
        }
 
        virtual Model::GetBackupPlanFromTemplateOutcome GetBackupPlanFromTemplate(const Model::GetBackupPlanFromTemplateRequest& request) const;
 
        template<typename GetBackupPlanFromTemplateRequestT = Model::GetBackupPlanFromTemplateRequest>
        Model::GetBackupPlanFromTemplateOutcomeCallable GetBackupPlanFromTemplateCallable(const GetBackupPlanFromTemplateRequestT& request) const
        {
            return SubmitCallable(&BackupClient::GetBackupPlanFromTemplate, request);
        }
 
        template<typename GetBackupPlanFromTemplateRequestT = Model::GetBackupPlanFromTemplateRequest>
        void GetBackupPlanFromTemplateAsync(const GetBackupPlanFromTemplateRequestT& request, const GetBackupPlanFromTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::GetBackupPlanFromTemplate, request, handler, context);
        }
 
        virtual Model::GetBackupSelectionOutcome GetBackupSelection(const Model::GetBackupSelectionRequest& request) const;
 
        template<typename GetBackupSelectionRequestT = Model::GetBackupSelectionRequest>
        Model::GetBackupSelectionOutcomeCallable GetBackupSelectionCallable(const GetBackupSelectionRequestT& request) const
        {
            return SubmitCallable(&BackupClient::GetBackupSelection, request);
        }
 
        template<typename GetBackupSelectionRequestT = Model::GetBackupSelectionRequest>
        void GetBackupSelectionAsync(const GetBackupSelectionRequestT& request, const GetBackupSelectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::GetBackupSelection, request, handler, context);
        }
 
        virtual Model::GetBackupVaultAccessPolicyOutcome GetBackupVaultAccessPolicy(const Model::GetBackupVaultAccessPolicyRequest& request) const;
 
        template<typename GetBackupVaultAccessPolicyRequestT = Model::GetBackupVaultAccessPolicyRequest>
        Model::GetBackupVaultAccessPolicyOutcomeCallable GetBackupVaultAccessPolicyCallable(const GetBackupVaultAccessPolicyRequestT& request) const
        {
            return SubmitCallable(&BackupClient::GetBackupVaultAccessPolicy, request);
        }
 
        template<typename GetBackupVaultAccessPolicyRequestT = Model::GetBackupVaultAccessPolicyRequest>
        void GetBackupVaultAccessPolicyAsync(const GetBackupVaultAccessPolicyRequestT& request, const GetBackupVaultAccessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::GetBackupVaultAccessPolicy, request, handler, context);
        }
 
        virtual Model::GetBackupVaultNotificationsOutcome GetBackupVaultNotifications(const Model::GetBackupVaultNotificationsRequest& request) const;
 
        template<typename GetBackupVaultNotificationsRequestT = Model::GetBackupVaultNotificationsRequest>
        Model::GetBackupVaultNotificationsOutcomeCallable GetBackupVaultNotificationsCallable(const GetBackupVaultNotificationsRequestT& request) const
        {
            return SubmitCallable(&BackupClient::GetBackupVaultNotifications, request);
        }
 
        template<typename GetBackupVaultNotificationsRequestT = Model::GetBackupVaultNotificationsRequest>
        void GetBackupVaultNotificationsAsync(const GetBackupVaultNotificationsRequestT& request, const GetBackupVaultNotificationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::GetBackupVaultNotifications, request, handler, context);
        }
 
        virtual Model::GetLegalHoldOutcome GetLegalHold(const Model::GetLegalHoldRequest& request) const;
 
        template<typename GetLegalHoldRequestT = Model::GetLegalHoldRequest>
        Model::GetLegalHoldOutcomeCallable GetLegalHoldCallable(const GetLegalHoldRequestT& request) const
        {
            return SubmitCallable(&BackupClient::GetLegalHold, request);
        }
 
        template<typename GetLegalHoldRequestT = Model::GetLegalHoldRequest>
        void GetLegalHoldAsync(const GetLegalHoldRequestT& request, const GetLegalHoldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::GetLegalHold, request, handler, context);
        }
 
        virtual Model::GetRecoveryPointIndexDetailsOutcome GetRecoveryPointIndexDetails(const Model::GetRecoveryPointIndexDetailsRequest& request) const;
 
        template<typename GetRecoveryPointIndexDetailsRequestT = Model::GetRecoveryPointIndexDetailsRequest>
        Model::GetRecoveryPointIndexDetailsOutcomeCallable GetRecoveryPointIndexDetailsCallable(const GetRecoveryPointIndexDetailsRequestT& request) const
        {
            return SubmitCallable(&BackupClient::GetRecoveryPointIndexDetails, request);
        }
 
        template<typename GetRecoveryPointIndexDetailsRequestT = Model::GetRecoveryPointIndexDetailsRequest>
        void GetRecoveryPointIndexDetailsAsync(const GetRecoveryPointIndexDetailsRequestT& request, const GetRecoveryPointIndexDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::GetRecoveryPointIndexDetails, request, handler, context);
        }
 
        virtual Model::GetRecoveryPointRestoreMetadataOutcome GetRecoveryPointRestoreMetadata(const Model::GetRecoveryPointRestoreMetadataRequest& request) const;
 
        template<typename GetRecoveryPointRestoreMetadataRequestT = Model::GetRecoveryPointRestoreMetadataRequest>
        Model::GetRecoveryPointRestoreMetadataOutcomeCallable GetRecoveryPointRestoreMetadataCallable(const GetRecoveryPointRestoreMetadataRequestT& request) const
        {
            return SubmitCallable(&BackupClient::GetRecoveryPointRestoreMetadata, request);
        }
 
        template<typename GetRecoveryPointRestoreMetadataRequestT = Model::GetRecoveryPointRestoreMetadataRequest>
        void GetRecoveryPointRestoreMetadataAsync(const GetRecoveryPointRestoreMetadataRequestT& request, const GetRecoveryPointRestoreMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::GetRecoveryPointRestoreMetadata, request, handler, context);
        }
 
        virtual Model::GetRestoreJobMetadataOutcome GetRestoreJobMetadata(const Model::GetRestoreJobMetadataRequest& request) const;
 
        template<typename GetRestoreJobMetadataRequestT = Model::GetRestoreJobMetadataRequest>
        Model::GetRestoreJobMetadataOutcomeCallable GetRestoreJobMetadataCallable(const GetRestoreJobMetadataRequestT& request) const
        {
            return SubmitCallable(&BackupClient::GetRestoreJobMetadata, request);
        }
 
        template<typename GetRestoreJobMetadataRequestT = Model::GetRestoreJobMetadataRequest>
        void GetRestoreJobMetadataAsync(const GetRestoreJobMetadataRequestT& request, const GetRestoreJobMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::GetRestoreJobMetadata, request, handler, context);
        }
 
        virtual Model::GetRestoreTestingInferredMetadataOutcome GetRestoreTestingInferredMetadata(const Model::GetRestoreTestingInferredMetadataRequest& request) const;
 
        template<typename GetRestoreTestingInferredMetadataRequestT = Model::GetRestoreTestingInferredMetadataRequest>
        Model::GetRestoreTestingInferredMetadataOutcomeCallable GetRestoreTestingInferredMetadataCallable(const GetRestoreTestingInferredMetadataRequestT& request) const
        {
            return SubmitCallable(&BackupClient::GetRestoreTestingInferredMetadata, request);
        }
 
        template<typename GetRestoreTestingInferredMetadataRequestT = Model::GetRestoreTestingInferredMetadataRequest>
        void GetRestoreTestingInferredMetadataAsync(const GetRestoreTestingInferredMetadataRequestT& request, const GetRestoreTestingInferredMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::GetRestoreTestingInferredMetadata, request, handler, context);
        }
 
        virtual Model::GetRestoreTestingPlanOutcome GetRestoreTestingPlan(const Model::GetRestoreTestingPlanRequest& request) const;
 
        template<typename GetRestoreTestingPlanRequestT = Model::GetRestoreTestingPlanRequest>
        Model::GetRestoreTestingPlanOutcomeCallable GetRestoreTestingPlanCallable(const GetRestoreTestingPlanRequestT& request) const
        {
            return SubmitCallable(&BackupClient::GetRestoreTestingPlan, request);
        }
 
        template<typename GetRestoreTestingPlanRequestT = Model::GetRestoreTestingPlanRequest>
        void GetRestoreTestingPlanAsync(const GetRestoreTestingPlanRequestT& request, const GetRestoreTestingPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::GetRestoreTestingPlan, request, handler, context);
        }
 
        virtual Model::GetRestoreTestingSelectionOutcome GetRestoreTestingSelection(const Model::GetRestoreTestingSelectionRequest& request) const;
 
        template<typename GetRestoreTestingSelectionRequestT = Model::GetRestoreTestingSelectionRequest>
        Model::GetRestoreTestingSelectionOutcomeCallable GetRestoreTestingSelectionCallable(const GetRestoreTestingSelectionRequestT& request) const
        {
            return SubmitCallable(&BackupClient::GetRestoreTestingSelection, request);
        }
 
        template<typename GetRestoreTestingSelectionRequestT = Model::GetRestoreTestingSelectionRequest>
        void GetRestoreTestingSelectionAsync(const GetRestoreTestingSelectionRequestT& request, const GetRestoreTestingSelectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::GetRestoreTestingSelection, request, handler, context);
        }
 
        virtual Model::GetSupportedResourceTypesOutcome GetSupportedResourceTypes(const Model::GetSupportedResourceTypesRequest& request = {}) const;
 
        template<typename GetSupportedResourceTypesRequestT = Model::GetSupportedResourceTypesRequest>
        Model::GetSupportedResourceTypesOutcomeCallable GetSupportedResourceTypesCallable(const GetSupportedResourceTypesRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::GetSupportedResourceTypes, request);
        }
 
        template<typename GetSupportedResourceTypesRequestT = Model::GetSupportedResourceTypesRequest>
        void GetSupportedResourceTypesAsync(const GetSupportedResourceTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetSupportedResourceTypesRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::GetSupportedResourceTypes, request, handler, context);
        }
 
        virtual Model::ListBackupJobSummariesOutcome ListBackupJobSummaries(const Model::ListBackupJobSummariesRequest& request = {}) const;
 
        template<typename ListBackupJobSummariesRequestT = Model::ListBackupJobSummariesRequest>
        Model::ListBackupJobSummariesOutcomeCallable ListBackupJobSummariesCallable(const ListBackupJobSummariesRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::ListBackupJobSummaries, request);
        }
 
        template<typename ListBackupJobSummariesRequestT = Model::ListBackupJobSummariesRequest>
        void ListBackupJobSummariesAsync(const ListBackupJobSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListBackupJobSummariesRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::ListBackupJobSummaries, request, handler, context);
        }
 
        virtual Model::ListBackupJobsOutcome ListBackupJobs(const Model::ListBackupJobsRequest& request = {}) const;
 
        template<typename ListBackupJobsRequestT = Model::ListBackupJobsRequest>
        Model::ListBackupJobsOutcomeCallable ListBackupJobsCallable(const ListBackupJobsRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::ListBackupJobs, request);
        }
 
        template<typename ListBackupJobsRequestT = Model::ListBackupJobsRequest>
        void ListBackupJobsAsync(const ListBackupJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListBackupJobsRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::ListBackupJobs, request, handler, context);
        }
 
        virtual Model::ListBackupPlanTemplatesOutcome ListBackupPlanTemplates(const Model::ListBackupPlanTemplatesRequest& request = {}) const;
 
        template<typename ListBackupPlanTemplatesRequestT = Model::ListBackupPlanTemplatesRequest>
        Model::ListBackupPlanTemplatesOutcomeCallable ListBackupPlanTemplatesCallable(const ListBackupPlanTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::ListBackupPlanTemplates, request);
        }
 
        template<typename ListBackupPlanTemplatesRequestT = Model::ListBackupPlanTemplatesRequest>
        void ListBackupPlanTemplatesAsync(const ListBackupPlanTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListBackupPlanTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::ListBackupPlanTemplates, request, handler, context);
        }
 
        virtual Model::ListBackupPlanVersionsOutcome ListBackupPlanVersions(const Model::ListBackupPlanVersionsRequest& request) const;
 
        template<typename ListBackupPlanVersionsRequestT = Model::ListBackupPlanVersionsRequest>
        Model::ListBackupPlanVersionsOutcomeCallable ListBackupPlanVersionsCallable(const ListBackupPlanVersionsRequestT& request) const
        {
            return SubmitCallable(&BackupClient::ListBackupPlanVersions, request);
        }
 
        template<typename ListBackupPlanVersionsRequestT = Model::ListBackupPlanVersionsRequest>
        void ListBackupPlanVersionsAsync(const ListBackupPlanVersionsRequestT& request, const ListBackupPlanVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::ListBackupPlanVersions, request, handler, context);
        }
 
        virtual Model::ListBackupPlansOutcome ListBackupPlans(const Model::ListBackupPlansRequest& request = {}) const;
 
        template<typename ListBackupPlansRequestT = Model::ListBackupPlansRequest>
        Model::ListBackupPlansOutcomeCallable ListBackupPlansCallable(const ListBackupPlansRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::ListBackupPlans, request);
        }
 
        template<typename ListBackupPlansRequestT = Model::ListBackupPlansRequest>
        void ListBackupPlansAsync(const ListBackupPlansResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListBackupPlansRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::ListBackupPlans, request, handler, context);
        }
 
        virtual Model::ListBackupSelectionsOutcome ListBackupSelections(const Model::ListBackupSelectionsRequest& request) const;
 
        template<typename ListBackupSelectionsRequestT = Model::ListBackupSelectionsRequest>
        Model::ListBackupSelectionsOutcomeCallable ListBackupSelectionsCallable(const ListBackupSelectionsRequestT& request) const
        {
            return SubmitCallable(&BackupClient::ListBackupSelections, request);
        }
 
        template<typename ListBackupSelectionsRequestT = Model::ListBackupSelectionsRequest>
        void ListBackupSelectionsAsync(const ListBackupSelectionsRequestT& request, const ListBackupSelectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::ListBackupSelections, request, handler, context);
        }
 
        virtual Model::ListBackupVaultsOutcome ListBackupVaults(const Model::ListBackupVaultsRequest& request = {}) const;
 
        template<typename ListBackupVaultsRequestT = Model::ListBackupVaultsRequest>
        Model::ListBackupVaultsOutcomeCallable ListBackupVaultsCallable(const ListBackupVaultsRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::ListBackupVaults, request);
        }
 
        template<typename ListBackupVaultsRequestT = Model::ListBackupVaultsRequest>
        void ListBackupVaultsAsync(const ListBackupVaultsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListBackupVaultsRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::ListBackupVaults, request, handler, context);
        }
 
        virtual Model::ListCopyJobSummariesOutcome ListCopyJobSummaries(const Model::ListCopyJobSummariesRequest& request = {}) const;
 
        template<typename ListCopyJobSummariesRequestT = Model::ListCopyJobSummariesRequest>
        Model::ListCopyJobSummariesOutcomeCallable ListCopyJobSummariesCallable(const ListCopyJobSummariesRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::ListCopyJobSummaries, request);
        }
 
        template<typename ListCopyJobSummariesRequestT = Model::ListCopyJobSummariesRequest>
        void ListCopyJobSummariesAsync(const ListCopyJobSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCopyJobSummariesRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::ListCopyJobSummaries, request, handler, context);
        }
 
        virtual Model::ListCopyJobsOutcome ListCopyJobs(const Model::ListCopyJobsRequest& request = {}) const;
 
        template<typename ListCopyJobsRequestT = Model::ListCopyJobsRequest>
        Model::ListCopyJobsOutcomeCallable ListCopyJobsCallable(const ListCopyJobsRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::ListCopyJobs, request);
        }
 
        template<typename ListCopyJobsRequestT = Model::ListCopyJobsRequest>
        void ListCopyJobsAsync(const ListCopyJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCopyJobsRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::ListCopyJobs, request, handler, context);
        }
 
        virtual Model::ListFrameworksOutcome ListFrameworks(const Model::ListFrameworksRequest& request = {}) const;
 
        template<typename ListFrameworksRequestT = Model::ListFrameworksRequest>
        Model::ListFrameworksOutcomeCallable ListFrameworksCallable(const ListFrameworksRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::ListFrameworks, request);
        }
 
        template<typename ListFrameworksRequestT = Model::ListFrameworksRequest>
        void ListFrameworksAsync(const ListFrameworksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListFrameworksRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::ListFrameworks, request, handler, context);
        }
 
        virtual Model::ListIndexedRecoveryPointsOutcome ListIndexedRecoveryPoints(const Model::ListIndexedRecoveryPointsRequest& request = {}) const;
 
        template<typename ListIndexedRecoveryPointsRequestT = Model::ListIndexedRecoveryPointsRequest>
        Model::ListIndexedRecoveryPointsOutcomeCallable ListIndexedRecoveryPointsCallable(const ListIndexedRecoveryPointsRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::ListIndexedRecoveryPoints, request);
        }
 
        template<typename ListIndexedRecoveryPointsRequestT = Model::ListIndexedRecoveryPointsRequest>
        void ListIndexedRecoveryPointsAsync(const ListIndexedRecoveryPointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListIndexedRecoveryPointsRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::ListIndexedRecoveryPoints, request, handler, context);
        }
 
        virtual Model::ListLegalHoldsOutcome ListLegalHolds(const Model::ListLegalHoldsRequest& request = {}) const;
 
        template<typename ListLegalHoldsRequestT = Model::ListLegalHoldsRequest>
        Model::ListLegalHoldsOutcomeCallable ListLegalHoldsCallable(const ListLegalHoldsRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::ListLegalHolds, request);
        }
 
        template<typename ListLegalHoldsRequestT = Model::ListLegalHoldsRequest>
        void ListLegalHoldsAsync(const ListLegalHoldsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLegalHoldsRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::ListLegalHolds, request, handler, context);
        }
 
        virtual Model::ListProtectedResourcesOutcome ListProtectedResources(const Model::ListProtectedResourcesRequest& request = {}) const;
 
        template<typename ListProtectedResourcesRequestT = Model::ListProtectedResourcesRequest>
        Model::ListProtectedResourcesOutcomeCallable ListProtectedResourcesCallable(const ListProtectedResourcesRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::ListProtectedResources, request);
        }
 
        template<typename ListProtectedResourcesRequestT = Model::ListProtectedResourcesRequest>
        void ListProtectedResourcesAsync(const ListProtectedResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListProtectedResourcesRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::ListProtectedResources, request, handler, context);
        }
 
        virtual Model::ListProtectedResourcesByBackupVaultOutcome ListProtectedResourcesByBackupVault(const Model::ListProtectedResourcesByBackupVaultRequest& request) const;
 
        template<typename ListProtectedResourcesByBackupVaultRequestT = Model::ListProtectedResourcesByBackupVaultRequest>
        Model::ListProtectedResourcesByBackupVaultOutcomeCallable ListProtectedResourcesByBackupVaultCallable(const ListProtectedResourcesByBackupVaultRequestT& request) const
        {
            return SubmitCallable(&BackupClient::ListProtectedResourcesByBackupVault, request);
        }
 
        template<typename ListProtectedResourcesByBackupVaultRequestT = Model::ListProtectedResourcesByBackupVaultRequest>
        void ListProtectedResourcesByBackupVaultAsync(const ListProtectedResourcesByBackupVaultRequestT& request, const ListProtectedResourcesByBackupVaultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::ListProtectedResourcesByBackupVault, request, handler, context);
        }
 
        virtual Model::ListRecoveryPointsByBackupVaultOutcome ListRecoveryPointsByBackupVault(const Model::ListRecoveryPointsByBackupVaultRequest& request) const;
 
        template<typename ListRecoveryPointsByBackupVaultRequestT = Model::ListRecoveryPointsByBackupVaultRequest>
        Model::ListRecoveryPointsByBackupVaultOutcomeCallable ListRecoveryPointsByBackupVaultCallable(const ListRecoveryPointsByBackupVaultRequestT& request) const
        {
            return SubmitCallable(&BackupClient::ListRecoveryPointsByBackupVault, request);
        }
 
        template<typename ListRecoveryPointsByBackupVaultRequestT = Model::ListRecoveryPointsByBackupVaultRequest>
        void ListRecoveryPointsByBackupVaultAsync(const ListRecoveryPointsByBackupVaultRequestT& request, const ListRecoveryPointsByBackupVaultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::ListRecoveryPointsByBackupVault, request, handler, context);
        }
 
        virtual Model::ListRecoveryPointsByLegalHoldOutcome ListRecoveryPointsByLegalHold(const Model::ListRecoveryPointsByLegalHoldRequest& request) const;
 
        template<typename ListRecoveryPointsByLegalHoldRequestT = Model::ListRecoveryPointsByLegalHoldRequest>
        Model::ListRecoveryPointsByLegalHoldOutcomeCallable ListRecoveryPointsByLegalHoldCallable(const ListRecoveryPointsByLegalHoldRequestT& request) const
        {
            return SubmitCallable(&BackupClient::ListRecoveryPointsByLegalHold, request);
        }
 
        template<typename ListRecoveryPointsByLegalHoldRequestT = Model::ListRecoveryPointsByLegalHoldRequest>
        void ListRecoveryPointsByLegalHoldAsync(const ListRecoveryPointsByLegalHoldRequestT& request, const ListRecoveryPointsByLegalHoldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::ListRecoveryPointsByLegalHold, request, handler, context);
        }
 
        virtual Model::ListRecoveryPointsByResourceOutcome ListRecoveryPointsByResource(const Model::ListRecoveryPointsByResourceRequest& request) const;
 
        template<typename ListRecoveryPointsByResourceRequestT = Model::ListRecoveryPointsByResourceRequest>
        Model::ListRecoveryPointsByResourceOutcomeCallable ListRecoveryPointsByResourceCallable(const ListRecoveryPointsByResourceRequestT& request) const
        {
            return SubmitCallable(&BackupClient::ListRecoveryPointsByResource, request);
        }
 
        template<typename ListRecoveryPointsByResourceRequestT = Model::ListRecoveryPointsByResourceRequest>
        void ListRecoveryPointsByResourceAsync(const ListRecoveryPointsByResourceRequestT& request, const ListRecoveryPointsByResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::ListRecoveryPointsByResource, request, handler, context);
        }
 
        virtual Model::ListReportJobsOutcome ListReportJobs(const Model::ListReportJobsRequest& request = {}) const;
 
        template<typename ListReportJobsRequestT = Model::ListReportJobsRequest>
        Model::ListReportJobsOutcomeCallable ListReportJobsCallable(const ListReportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::ListReportJobs, request);
        }
 
        template<typename ListReportJobsRequestT = Model::ListReportJobsRequest>
        void ListReportJobsAsync(const ListReportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListReportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::ListReportJobs, request, handler, context);
        }
 
        virtual Model::ListReportPlansOutcome ListReportPlans(const Model::ListReportPlansRequest& request = {}) const;
 
        template<typename ListReportPlansRequestT = Model::ListReportPlansRequest>
        Model::ListReportPlansOutcomeCallable ListReportPlansCallable(const ListReportPlansRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::ListReportPlans, request);
        }
 
        template<typename ListReportPlansRequestT = Model::ListReportPlansRequest>
        void ListReportPlansAsync(const ListReportPlansResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListReportPlansRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::ListReportPlans, request, handler, context);
        }
 
        virtual Model::ListRestoreAccessBackupVaultsOutcome ListRestoreAccessBackupVaults(const Model::ListRestoreAccessBackupVaultsRequest& request) const;
 
        template<typename ListRestoreAccessBackupVaultsRequestT = Model::ListRestoreAccessBackupVaultsRequest>
        Model::ListRestoreAccessBackupVaultsOutcomeCallable ListRestoreAccessBackupVaultsCallable(const ListRestoreAccessBackupVaultsRequestT& request) const
        {
            return SubmitCallable(&BackupClient::ListRestoreAccessBackupVaults, request);
        }
 
        template<typename ListRestoreAccessBackupVaultsRequestT = Model::ListRestoreAccessBackupVaultsRequest>
        void ListRestoreAccessBackupVaultsAsync(const ListRestoreAccessBackupVaultsRequestT& request, const ListRestoreAccessBackupVaultsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::ListRestoreAccessBackupVaults, request, handler, context);
        }
 
        virtual Model::ListRestoreJobSummariesOutcome ListRestoreJobSummaries(const Model::ListRestoreJobSummariesRequest& request = {}) const;
 
        template<typename ListRestoreJobSummariesRequestT = Model::ListRestoreJobSummariesRequest>
        Model::ListRestoreJobSummariesOutcomeCallable ListRestoreJobSummariesCallable(const ListRestoreJobSummariesRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::ListRestoreJobSummaries, request);
        }
 
        template<typename ListRestoreJobSummariesRequestT = Model::ListRestoreJobSummariesRequest>
        void ListRestoreJobSummariesAsync(const ListRestoreJobSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRestoreJobSummariesRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::ListRestoreJobSummaries, request, handler, context);
        }
 
        virtual Model::ListRestoreJobsOutcome ListRestoreJobs(const Model::ListRestoreJobsRequest& request = {}) const;
 
        template<typename ListRestoreJobsRequestT = Model::ListRestoreJobsRequest>
        Model::ListRestoreJobsOutcomeCallable ListRestoreJobsCallable(const ListRestoreJobsRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::ListRestoreJobs, request);
        }
 
        template<typename ListRestoreJobsRequestT = Model::ListRestoreJobsRequest>
        void ListRestoreJobsAsync(const ListRestoreJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRestoreJobsRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::ListRestoreJobs, request, handler, context);
        }
 
        virtual Model::ListRestoreJobsByProtectedResourceOutcome ListRestoreJobsByProtectedResource(const Model::ListRestoreJobsByProtectedResourceRequest& request) const;
 
        template<typename ListRestoreJobsByProtectedResourceRequestT = Model::ListRestoreJobsByProtectedResourceRequest>
        Model::ListRestoreJobsByProtectedResourceOutcomeCallable ListRestoreJobsByProtectedResourceCallable(const ListRestoreJobsByProtectedResourceRequestT& request) const
        {
            return SubmitCallable(&BackupClient::ListRestoreJobsByProtectedResource, request);
        }
 
        template<typename ListRestoreJobsByProtectedResourceRequestT = Model::ListRestoreJobsByProtectedResourceRequest>
        void ListRestoreJobsByProtectedResourceAsync(const ListRestoreJobsByProtectedResourceRequestT& request, const ListRestoreJobsByProtectedResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::ListRestoreJobsByProtectedResource, request, handler, context);
        }
 
        virtual Model::ListRestoreTestingPlansOutcome ListRestoreTestingPlans(const Model::ListRestoreTestingPlansRequest& request = {}) const;
 
        template<typename ListRestoreTestingPlansRequestT = Model::ListRestoreTestingPlansRequest>
        Model::ListRestoreTestingPlansOutcomeCallable ListRestoreTestingPlansCallable(const ListRestoreTestingPlansRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::ListRestoreTestingPlans, request);
        }
 
        template<typename ListRestoreTestingPlansRequestT = Model::ListRestoreTestingPlansRequest>
        void ListRestoreTestingPlansAsync(const ListRestoreTestingPlansResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRestoreTestingPlansRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::ListRestoreTestingPlans, request, handler, context);
        }
 
        virtual Model::ListRestoreTestingSelectionsOutcome ListRestoreTestingSelections(const Model::ListRestoreTestingSelectionsRequest& request) const;
 
        template<typename ListRestoreTestingSelectionsRequestT = Model::ListRestoreTestingSelectionsRequest>
        Model::ListRestoreTestingSelectionsOutcomeCallable ListRestoreTestingSelectionsCallable(const ListRestoreTestingSelectionsRequestT& request) const
        {
            return SubmitCallable(&BackupClient::ListRestoreTestingSelections, request);
        }
 
        template<typename ListRestoreTestingSelectionsRequestT = Model::ListRestoreTestingSelectionsRequest>
        void ListRestoreTestingSelectionsAsync(const ListRestoreTestingSelectionsRequestT& request, const ListRestoreTestingSelectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::ListRestoreTestingSelections, request, handler, context);
        }
 
        virtual Model::ListTagsOutcome ListTags(const Model::ListTagsRequest& request) const;
 
        template<typename ListTagsRequestT = Model::ListTagsRequest>
        Model::ListTagsOutcomeCallable ListTagsCallable(const ListTagsRequestT& request) const
        {
            return SubmitCallable(&BackupClient::ListTags, request);
        }
 
        template<typename ListTagsRequestT = Model::ListTagsRequest>
        void ListTagsAsync(const ListTagsRequestT& request, const ListTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::ListTags, request, handler, context);
        }
 
        virtual Model::PutBackupVaultAccessPolicyOutcome PutBackupVaultAccessPolicy(const Model::PutBackupVaultAccessPolicyRequest& request) const;
 
        template<typename PutBackupVaultAccessPolicyRequestT = Model::PutBackupVaultAccessPolicyRequest>
        Model::PutBackupVaultAccessPolicyOutcomeCallable PutBackupVaultAccessPolicyCallable(const PutBackupVaultAccessPolicyRequestT& request) const
        {
            return SubmitCallable(&BackupClient::PutBackupVaultAccessPolicy, request);
        }
 
        template<typename PutBackupVaultAccessPolicyRequestT = Model::PutBackupVaultAccessPolicyRequest>
        void PutBackupVaultAccessPolicyAsync(const PutBackupVaultAccessPolicyRequestT& request, const PutBackupVaultAccessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::PutBackupVaultAccessPolicy, request, handler, context);
        }
 
        virtual Model::PutBackupVaultLockConfigurationOutcome PutBackupVaultLockConfiguration(const Model::PutBackupVaultLockConfigurationRequest& request) const;
 
        template<typename PutBackupVaultLockConfigurationRequestT = Model::PutBackupVaultLockConfigurationRequest>
        Model::PutBackupVaultLockConfigurationOutcomeCallable PutBackupVaultLockConfigurationCallable(const PutBackupVaultLockConfigurationRequestT& request) const
        {
            return SubmitCallable(&BackupClient::PutBackupVaultLockConfiguration, request);
        }
 
        template<typename PutBackupVaultLockConfigurationRequestT = Model::PutBackupVaultLockConfigurationRequest>
        void PutBackupVaultLockConfigurationAsync(const PutBackupVaultLockConfigurationRequestT& request, const PutBackupVaultLockConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::PutBackupVaultLockConfiguration, request, handler, context);
        }
 
        virtual Model::PutBackupVaultNotificationsOutcome PutBackupVaultNotifications(const Model::PutBackupVaultNotificationsRequest& request) const;
 
        template<typename PutBackupVaultNotificationsRequestT = Model::PutBackupVaultNotificationsRequest>
        Model::PutBackupVaultNotificationsOutcomeCallable PutBackupVaultNotificationsCallable(const PutBackupVaultNotificationsRequestT& request) const
        {
            return SubmitCallable(&BackupClient::PutBackupVaultNotifications, request);
        }
 
        template<typename PutBackupVaultNotificationsRequestT = Model::PutBackupVaultNotificationsRequest>
        void PutBackupVaultNotificationsAsync(const PutBackupVaultNotificationsRequestT& request, const PutBackupVaultNotificationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::PutBackupVaultNotifications, request, handler, context);
        }
 
        virtual Model::PutRestoreValidationResultOutcome PutRestoreValidationResult(const Model::PutRestoreValidationResultRequest& request) const;
 
        template<typename PutRestoreValidationResultRequestT = Model::PutRestoreValidationResultRequest>
        Model::PutRestoreValidationResultOutcomeCallable PutRestoreValidationResultCallable(const PutRestoreValidationResultRequestT& request) const
        {
            return SubmitCallable(&BackupClient::PutRestoreValidationResult, request);
        }
 
        template<typename PutRestoreValidationResultRequestT = Model::PutRestoreValidationResultRequest>
        void PutRestoreValidationResultAsync(const PutRestoreValidationResultRequestT& request, const PutRestoreValidationResultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::PutRestoreValidationResult, request, handler, context);
        }
 
        virtual Model::RevokeRestoreAccessBackupVaultOutcome RevokeRestoreAccessBackupVault(const Model::RevokeRestoreAccessBackupVaultRequest& request) const;
 
        template<typename RevokeRestoreAccessBackupVaultRequestT = Model::RevokeRestoreAccessBackupVaultRequest>
        Model::RevokeRestoreAccessBackupVaultOutcomeCallable RevokeRestoreAccessBackupVaultCallable(const RevokeRestoreAccessBackupVaultRequestT& request) const
        {
            return SubmitCallable(&BackupClient::RevokeRestoreAccessBackupVault, request);
        }
 
        template<typename RevokeRestoreAccessBackupVaultRequestT = Model::RevokeRestoreAccessBackupVaultRequest>
        void RevokeRestoreAccessBackupVaultAsync(const RevokeRestoreAccessBackupVaultRequestT& request, const RevokeRestoreAccessBackupVaultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::RevokeRestoreAccessBackupVault, request, handler, context);
        }
 
        virtual Model::StartBackupJobOutcome StartBackupJob(const Model::StartBackupJobRequest& request) const;
 
        template<typename StartBackupJobRequestT = Model::StartBackupJobRequest>
        Model::StartBackupJobOutcomeCallable StartBackupJobCallable(const StartBackupJobRequestT& request) const
        {
            return SubmitCallable(&BackupClient::StartBackupJob, request);
        }
 
        template<typename StartBackupJobRequestT = Model::StartBackupJobRequest>
        void StartBackupJobAsync(const StartBackupJobRequestT& request, const StartBackupJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::StartBackupJob, request, handler, context);
        }
 
        virtual Model::StartCopyJobOutcome StartCopyJob(const Model::StartCopyJobRequest& request) const;
 
        template<typename StartCopyJobRequestT = Model::StartCopyJobRequest>
        Model::StartCopyJobOutcomeCallable StartCopyJobCallable(const StartCopyJobRequestT& request) const
        {
            return SubmitCallable(&BackupClient::StartCopyJob, request);
        }
 
        template<typename StartCopyJobRequestT = Model::StartCopyJobRequest>
        void StartCopyJobAsync(const StartCopyJobRequestT& request, const StartCopyJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::StartCopyJob, request, handler, context);
        }
 
        virtual Model::StartReportJobOutcome StartReportJob(const Model::StartReportJobRequest& request) const;
 
        template<typename StartReportJobRequestT = Model::StartReportJobRequest>
        Model::StartReportJobOutcomeCallable StartReportJobCallable(const StartReportJobRequestT& request) const
        {
            return SubmitCallable(&BackupClient::StartReportJob, request);
        }
 
        template<typename StartReportJobRequestT = Model::StartReportJobRequest>
        void StartReportJobAsync(const StartReportJobRequestT& request, const StartReportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::StartReportJob, request, handler, context);
        }
 
        virtual Model::StartRestoreJobOutcome StartRestoreJob(const Model::StartRestoreJobRequest& request) const;
 
        template<typename StartRestoreJobRequestT = Model::StartRestoreJobRequest>
        Model::StartRestoreJobOutcomeCallable StartRestoreJobCallable(const StartRestoreJobRequestT& request) const
        {
            return SubmitCallable(&BackupClient::StartRestoreJob, request);
        }
 
        template<typename StartRestoreJobRequestT = Model::StartRestoreJobRequest>
        void StartRestoreJobAsync(const StartRestoreJobRequestT& request, const StartRestoreJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::StartRestoreJob, request, handler, context);
        }
 
        virtual Model::StopBackupJobOutcome StopBackupJob(const Model::StopBackupJobRequest& request) const;
 
        template<typename StopBackupJobRequestT = Model::StopBackupJobRequest>
        Model::StopBackupJobOutcomeCallable StopBackupJobCallable(const StopBackupJobRequestT& request) const
        {
            return SubmitCallable(&BackupClient::StopBackupJob, request);
        }
 
        template<typename StopBackupJobRequestT = Model::StopBackupJobRequest>
        void StopBackupJobAsync(const StopBackupJobRequestT& request, const StopBackupJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::StopBackupJob, 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(&BackupClient::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(&BackupClient::TagResource, 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(&BackupClient::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(&BackupClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateBackupPlanOutcome UpdateBackupPlan(const Model::UpdateBackupPlanRequest& request) const;
 
        template<typename UpdateBackupPlanRequestT = Model::UpdateBackupPlanRequest>
        Model::UpdateBackupPlanOutcomeCallable UpdateBackupPlanCallable(const UpdateBackupPlanRequestT& request) const
        {
            return SubmitCallable(&BackupClient::UpdateBackupPlan, request);
        }
 
        template<typename UpdateBackupPlanRequestT = Model::UpdateBackupPlanRequest>
        void UpdateBackupPlanAsync(const UpdateBackupPlanRequestT& request, const UpdateBackupPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::UpdateBackupPlan, request, handler, context);
        }
 
        virtual Model::UpdateFrameworkOutcome UpdateFramework(const Model::UpdateFrameworkRequest& request) const;
 
        template<typename UpdateFrameworkRequestT = Model::UpdateFrameworkRequest>
        Model::UpdateFrameworkOutcomeCallable UpdateFrameworkCallable(const UpdateFrameworkRequestT& request) const
        {
            return SubmitCallable(&BackupClient::UpdateFramework, request);
        }
 
        template<typename UpdateFrameworkRequestT = Model::UpdateFrameworkRequest>
        void UpdateFrameworkAsync(const UpdateFrameworkRequestT& request, const UpdateFrameworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::UpdateFramework, request, handler, context);
        }
 
        virtual Model::UpdateGlobalSettingsOutcome UpdateGlobalSettings(const Model::UpdateGlobalSettingsRequest& request = {}) const;
 
        template<typename UpdateGlobalSettingsRequestT = Model::UpdateGlobalSettingsRequest>
        Model::UpdateGlobalSettingsOutcomeCallable UpdateGlobalSettingsCallable(const UpdateGlobalSettingsRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::UpdateGlobalSettings, request);
        }
 
        template<typename UpdateGlobalSettingsRequestT = Model::UpdateGlobalSettingsRequest>
        void UpdateGlobalSettingsAsync(const UpdateGlobalSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateGlobalSettingsRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::UpdateGlobalSettings, request, handler, context);
        }
 
        virtual Model::UpdateRecoveryPointIndexSettingsOutcome UpdateRecoveryPointIndexSettings(const Model::UpdateRecoveryPointIndexSettingsRequest& request) const;
 
        template<typename UpdateRecoveryPointIndexSettingsRequestT = Model::UpdateRecoveryPointIndexSettingsRequest>
        Model::UpdateRecoveryPointIndexSettingsOutcomeCallable UpdateRecoveryPointIndexSettingsCallable(const UpdateRecoveryPointIndexSettingsRequestT& request) const
        {
            return SubmitCallable(&BackupClient::UpdateRecoveryPointIndexSettings, request);
        }
 
        template<typename UpdateRecoveryPointIndexSettingsRequestT = Model::UpdateRecoveryPointIndexSettingsRequest>
        void UpdateRecoveryPointIndexSettingsAsync(const UpdateRecoveryPointIndexSettingsRequestT& request, const UpdateRecoveryPointIndexSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::UpdateRecoveryPointIndexSettings, request, handler, context);
        }
 
        virtual Model::UpdateRecoveryPointLifecycleOutcome UpdateRecoveryPointLifecycle(const Model::UpdateRecoveryPointLifecycleRequest& request) const;
 
        template<typename UpdateRecoveryPointLifecycleRequestT = Model::UpdateRecoveryPointLifecycleRequest>
        Model::UpdateRecoveryPointLifecycleOutcomeCallable UpdateRecoveryPointLifecycleCallable(const UpdateRecoveryPointLifecycleRequestT& request) const
        {
            return SubmitCallable(&BackupClient::UpdateRecoveryPointLifecycle, request);
        }
 
        template<typename UpdateRecoveryPointLifecycleRequestT = Model::UpdateRecoveryPointLifecycleRequest>
        void UpdateRecoveryPointLifecycleAsync(const UpdateRecoveryPointLifecycleRequestT& request, const UpdateRecoveryPointLifecycleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::UpdateRecoveryPointLifecycle, request, handler, context);
        }
 
        virtual Model::UpdateRegionSettingsOutcome UpdateRegionSettings(const Model::UpdateRegionSettingsRequest& request = {}) const;
 
        template<typename UpdateRegionSettingsRequestT = Model::UpdateRegionSettingsRequest>
        Model::UpdateRegionSettingsOutcomeCallable UpdateRegionSettingsCallable(const UpdateRegionSettingsRequestT& request = {}) const
        {
            return SubmitCallable(&BackupClient::UpdateRegionSettings, request);
        }
 
        template<typename UpdateRegionSettingsRequestT = Model::UpdateRegionSettingsRequest>
        void UpdateRegionSettingsAsync(const UpdateRegionSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateRegionSettingsRequestT& request = {}) const
        {
            return SubmitAsync(&BackupClient::UpdateRegionSettings, request, handler, context);
        }
 
        virtual Model::UpdateReportPlanOutcome UpdateReportPlan(const Model::UpdateReportPlanRequest& request) const;
 
        template<typename UpdateReportPlanRequestT = Model::UpdateReportPlanRequest>
        Model::UpdateReportPlanOutcomeCallable UpdateReportPlanCallable(const UpdateReportPlanRequestT& request) const
        {
            return SubmitCallable(&BackupClient::UpdateReportPlan, request);
        }
 
        template<typename UpdateReportPlanRequestT = Model::UpdateReportPlanRequest>
        void UpdateReportPlanAsync(const UpdateReportPlanRequestT& request, const UpdateReportPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::UpdateReportPlan, request, handler, context);
        }
 
        virtual Model::UpdateRestoreTestingPlanOutcome UpdateRestoreTestingPlan(const Model::UpdateRestoreTestingPlanRequest& request) const;
 
        template<typename UpdateRestoreTestingPlanRequestT = Model::UpdateRestoreTestingPlanRequest>
        Model::UpdateRestoreTestingPlanOutcomeCallable UpdateRestoreTestingPlanCallable(const UpdateRestoreTestingPlanRequestT& request) const
        {
            return SubmitCallable(&BackupClient::UpdateRestoreTestingPlan, request);
        }
 
        template<typename UpdateRestoreTestingPlanRequestT = Model::UpdateRestoreTestingPlanRequest>
        void UpdateRestoreTestingPlanAsync(const UpdateRestoreTestingPlanRequestT& request, const UpdateRestoreTestingPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::UpdateRestoreTestingPlan, request, handler, context);
        }
 
        virtual Model::UpdateRestoreTestingSelectionOutcome UpdateRestoreTestingSelection(const Model::UpdateRestoreTestingSelectionRequest& request) const;
 
        template<typename UpdateRestoreTestingSelectionRequestT = Model::UpdateRestoreTestingSelectionRequest>
        Model::UpdateRestoreTestingSelectionOutcomeCallable UpdateRestoreTestingSelectionCallable(const UpdateRestoreTestingSelectionRequestT& request) const
        {
            return SubmitCallable(&BackupClient::UpdateRestoreTestingSelection, request);
        }
 
        template<typename UpdateRestoreTestingSelectionRequestT = Model::UpdateRestoreTestingSelectionRequest>
        void UpdateRestoreTestingSelectionAsync(const UpdateRestoreTestingSelectionRequestT& request, const UpdateRestoreTestingSelectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupClient::UpdateRestoreTestingSelection, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<BackupEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<BackupClient>;
      void init(const BackupClientConfiguration& clientConfiguration);
 
      BackupClientConfiguration m_clientConfiguration;
      std::shared_ptr<BackupEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Backup
} // namespace Aws