BackupClient.h

 
#pragma once
#include <aws/backup/BackupPaginationBase.h>
#include <aws/backup/BackupServiceClientModel.h>
#include <aws/backup/Backup_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace Backup {
class AWS_BACKUP_API BackupClient : public Aws::Client::AWSJsonClient,
                                    public Aws::Client::ClientWithAsyncTemplateMethods<BackupClient>,
                                    public BackupPaginationBase<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::CreateTieringConfigurationOutcome CreateTieringConfiguration(
      const Model::CreateTieringConfigurationRequest& request) const;
 
  template <typename CreateTieringConfigurationRequestT = Model::CreateTieringConfigurationRequest>
  Model::CreateTieringConfigurationOutcomeCallable CreateTieringConfigurationCallable(
      const CreateTieringConfigurationRequestT& request) const {
    return SubmitCallable(&BackupClient::CreateTieringConfiguration, request);
  }
 
  template <typename CreateTieringConfigurationRequestT = Model::CreateTieringConfigurationRequest>
  void CreateTieringConfigurationAsync(const CreateTieringConfigurationRequestT& request,
                                       const CreateTieringConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupClient::CreateTieringConfiguration, 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::DeleteTieringConfigurationOutcome DeleteTieringConfiguration(
      const Model::DeleteTieringConfigurationRequest& request) const;
 
  template <typename DeleteTieringConfigurationRequestT = Model::DeleteTieringConfigurationRequest>
  Model::DeleteTieringConfigurationOutcomeCallable DeleteTieringConfigurationCallable(
      const DeleteTieringConfigurationRequestT& request) const {
    return SubmitCallable(&BackupClient::DeleteTieringConfiguration, request);
  }
 
  template <typename DeleteTieringConfigurationRequestT = Model::DeleteTieringConfigurationRequest>
  void DeleteTieringConfigurationAsync(const DeleteTieringConfigurationRequestT& request,
                                       const DeleteTieringConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupClient::DeleteTieringConfiguration, 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::DescribeScanJobOutcome DescribeScanJob(const Model::DescribeScanJobRequest& request) const;
 
  template <typename DescribeScanJobRequestT = Model::DescribeScanJobRequest>
  Model::DescribeScanJobOutcomeCallable DescribeScanJobCallable(const DescribeScanJobRequestT& request) const {
    return SubmitCallable(&BackupClient::DescribeScanJob, request);
  }
 
  template <typename DescribeScanJobRequestT = Model::DescribeScanJobRequest>
  void DescribeScanJobAsync(const DescribeScanJobRequestT& request, const DescribeScanJobResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupClient::DescribeScanJob, 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::GetTieringConfigurationOutcome GetTieringConfiguration(const Model::GetTieringConfigurationRequest& request) const;
 
  template <typename GetTieringConfigurationRequestT = Model::GetTieringConfigurationRequest>
  Model::GetTieringConfigurationOutcomeCallable GetTieringConfigurationCallable(const GetTieringConfigurationRequestT& request) const {
    return SubmitCallable(&BackupClient::GetTieringConfiguration, request);
  }
 
  template <typename GetTieringConfigurationRequestT = Model::GetTieringConfigurationRequest>
  void GetTieringConfigurationAsync(const GetTieringConfigurationRequestT& request,
                                    const GetTieringConfigurationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupClient::GetTieringConfiguration, 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::ListScanJobSummariesOutcome ListScanJobSummaries(const Model::ListScanJobSummariesRequest& request = {}) const;
 
  template <typename ListScanJobSummariesRequestT = Model::ListScanJobSummariesRequest>
  Model::ListScanJobSummariesOutcomeCallable ListScanJobSummariesCallable(const ListScanJobSummariesRequestT& request = {}) const {
    return SubmitCallable(&BackupClient::ListScanJobSummaries, request);
  }
 
  template <typename ListScanJobSummariesRequestT = Model::ListScanJobSummariesRequest>
  void ListScanJobSummariesAsync(const ListScanJobSummariesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListScanJobSummariesRequestT& request = {}) const {
    return SubmitAsync(&BackupClient::ListScanJobSummaries, request, handler, context);
  }
 
  virtual Model::ListScanJobsOutcome ListScanJobs(const Model::ListScanJobsRequest& request = {}) const;
 
  template <typename ListScanJobsRequestT = Model::ListScanJobsRequest>
  Model::ListScanJobsOutcomeCallable ListScanJobsCallable(const ListScanJobsRequestT& request = {}) const {
    return SubmitCallable(&BackupClient::ListScanJobs, request);
  }
 
  template <typename ListScanJobsRequestT = Model::ListScanJobsRequest>
  void ListScanJobsAsync(const ListScanJobsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListScanJobsRequestT& request = {}) const {
    return SubmitAsync(&BackupClient::ListScanJobs, 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::ListTieringConfigurationsOutcome ListTieringConfigurations(
      const Model::ListTieringConfigurationsRequest& request = {}) const;
 
  template <typename ListTieringConfigurationsRequestT = Model::ListTieringConfigurationsRequest>
  Model::ListTieringConfigurationsOutcomeCallable ListTieringConfigurationsCallable(
      const ListTieringConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&BackupClient::ListTieringConfigurations, request);
  }
 
  template <typename ListTieringConfigurationsRequestT = Model::ListTieringConfigurationsRequest>
  void ListTieringConfigurationsAsync(const ListTieringConfigurationsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListTieringConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&BackupClient::ListTieringConfigurations, 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::StartScanJobOutcome StartScanJob(const Model::StartScanJobRequest& request) const;
 
  template <typename StartScanJobRequestT = Model::StartScanJobRequest>
  Model::StartScanJobOutcomeCallable StartScanJobCallable(const StartScanJobRequestT& request) const {
    return SubmitCallable(&BackupClient::StartScanJob, request);
  }
 
  template <typename StartScanJobRequestT = Model::StartScanJobRequest>
  void StartScanJobAsync(const StartScanJobRequestT& request, const StartScanJobResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupClient::StartScanJob, 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);
  }
 
  virtual Model::UpdateTieringConfigurationOutcome UpdateTieringConfiguration(
      const Model::UpdateTieringConfigurationRequest& request) const;
 
  template <typename UpdateTieringConfigurationRequestT = Model::UpdateTieringConfigurationRequest>
  Model::UpdateTieringConfigurationOutcomeCallable UpdateTieringConfigurationCallable(
      const UpdateTieringConfigurationRequestT& request) const {
    return SubmitCallable(&BackupClient::UpdateTieringConfiguration, request);
  }
 
  template <typename UpdateTieringConfigurationRequestT = Model::UpdateTieringConfigurationRequest>
  void UpdateTieringConfigurationAsync(const UpdateTieringConfigurationRequestT& request,
                                       const UpdateTieringConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BackupClient::UpdateTieringConfiguration, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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