AuditManagerClient.h

 
#pragma once
#include <aws/auditmanager/AuditManagerPaginationBase.h>
#include <aws/auditmanager/AuditManagerServiceClientModel.h>
#include <aws/auditmanager/AuditManagerWaiter.h>
#include <aws/auditmanager/AuditManager_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 AuditManager {
class AWS_AUDITMANAGER_API AuditManagerClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<AuditManagerClient>,
                                                public AuditManagerPaginationBase<AuditManagerClient>,
                                                public AuditManagerWaiter<AuditManagerClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef AuditManagerClientConfiguration ClientConfigurationType;
  typedef AuditManagerEndpointProvider EndpointProviderType;
 
  AuditManagerClient(
      const Aws::AuditManager::AuditManagerClientConfiguration& clientConfiguration = Aws::AuditManager::AuditManagerClientConfiguration(),
      std::shared_ptr<AuditManagerEndpointProviderBase> endpointProvider = nullptr);
 
  AuditManagerClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<AuditManagerEndpointProviderBase> endpointProvider = nullptr,
      const Aws::AuditManager::AuditManagerClientConfiguration& clientConfiguration = Aws::AuditManager::AuditManagerClientConfiguration());
 
  AuditManagerClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<AuditManagerEndpointProviderBase> endpointProvider = nullptr,
      const Aws::AuditManager::AuditManagerClientConfiguration& clientConfiguration = Aws::AuditManager::AuditManagerClientConfiguration());
 
  /* Legacy constructors due deprecation */
  AuditManagerClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AuditManagerClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AuditManagerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~AuditManagerClient();
 
  virtual Model::AssociateAssessmentReportEvidenceFolderOutcome AssociateAssessmentReportEvidenceFolder(
      const Model::AssociateAssessmentReportEvidenceFolderRequest& request) const;
 
  template <typename AssociateAssessmentReportEvidenceFolderRequestT = Model::AssociateAssessmentReportEvidenceFolderRequest>
  Model::AssociateAssessmentReportEvidenceFolderOutcomeCallable AssociateAssessmentReportEvidenceFolderCallable(
      const AssociateAssessmentReportEvidenceFolderRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::AssociateAssessmentReportEvidenceFolder, request);
  }
 
  template <typename AssociateAssessmentReportEvidenceFolderRequestT = Model::AssociateAssessmentReportEvidenceFolderRequest>
  void AssociateAssessmentReportEvidenceFolderAsync(const AssociateAssessmentReportEvidenceFolderRequestT& request,
                                                    const AssociateAssessmentReportEvidenceFolderResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::AssociateAssessmentReportEvidenceFolder, request, handler, context);
  }
 
  virtual Model::BatchAssociateAssessmentReportEvidenceOutcome BatchAssociateAssessmentReportEvidence(
      const Model::BatchAssociateAssessmentReportEvidenceRequest& request) const;
 
  template <typename BatchAssociateAssessmentReportEvidenceRequestT = Model::BatchAssociateAssessmentReportEvidenceRequest>
  Model::BatchAssociateAssessmentReportEvidenceOutcomeCallable BatchAssociateAssessmentReportEvidenceCallable(
      const BatchAssociateAssessmentReportEvidenceRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::BatchAssociateAssessmentReportEvidence, request);
  }
 
  template <typename BatchAssociateAssessmentReportEvidenceRequestT = Model::BatchAssociateAssessmentReportEvidenceRequest>
  void BatchAssociateAssessmentReportEvidenceAsync(const BatchAssociateAssessmentReportEvidenceRequestT& request,
                                                   const BatchAssociateAssessmentReportEvidenceResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::BatchAssociateAssessmentReportEvidence, request, handler, context);
  }
 
  virtual Model::BatchCreateDelegationByAssessmentOutcome BatchCreateDelegationByAssessment(
      const Model::BatchCreateDelegationByAssessmentRequest& request) const;
 
  template <typename BatchCreateDelegationByAssessmentRequestT = Model::BatchCreateDelegationByAssessmentRequest>
  Model::BatchCreateDelegationByAssessmentOutcomeCallable BatchCreateDelegationByAssessmentCallable(
      const BatchCreateDelegationByAssessmentRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::BatchCreateDelegationByAssessment, request);
  }
 
  template <typename BatchCreateDelegationByAssessmentRequestT = Model::BatchCreateDelegationByAssessmentRequest>
  void BatchCreateDelegationByAssessmentAsync(const BatchCreateDelegationByAssessmentRequestT& request,
                                              const BatchCreateDelegationByAssessmentResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::BatchCreateDelegationByAssessment, request, handler, context);
  }
 
  virtual Model::BatchDeleteDelegationByAssessmentOutcome BatchDeleteDelegationByAssessment(
      const Model::BatchDeleteDelegationByAssessmentRequest& request) const;
 
  template <typename BatchDeleteDelegationByAssessmentRequestT = Model::BatchDeleteDelegationByAssessmentRequest>
  Model::BatchDeleteDelegationByAssessmentOutcomeCallable BatchDeleteDelegationByAssessmentCallable(
      const BatchDeleteDelegationByAssessmentRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::BatchDeleteDelegationByAssessment, request);
  }
 
  template <typename BatchDeleteDelegationByAssessmentRequestT = Model::BatchDeleteDelegationByAssessmentRequest>
  void BatchDeleteDelegationByAssessmentAsync(const BatchDeleteDelegationByAssessmentRequestT& request,
                                              const BatchDeleteDelegationByAssessmentResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::BatchDeleteDelegationByAssessment, request, handler, context);
  }
 
  virtual Model::BatchDisassociateAssessmentReportEvidenceOutcome BatchDisassociateAssessmentReportEvidence(
      const Model::BatchDisassociateAssessmentReportEvidenceRequest& request) const;
 
  template <typename BatchDisassociateAssessmentReportEvidenceRequestT = Model::BatchDisassociateAssessmentReportEvidenceRequest>
  Model::BatchDisassociateAssessmentReportEvidenceOutcomeCallable BatchDisassociateAssessmentReportEvidenceCallable(
      const BatchDisassociateAssessmentReportEvidenceRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::BatchDisassociateAssessmentReportEvidence, request);
  }
 
  template <typename BatchDisassociateAssessmentReportEvidenceRequestT = Model::BatchDisassociateAssessmentReportEvidenceRequest>
  void BatchDisassociateAssessmentReportEvidenceAsync(
      const BatchDisassociateAssessmentReportEvidenceRequestT& request,
      const BatchDisassociateAssessmentReportEvidenceResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::BatchDisassociateAssessmentReportEvidence, request, handler, context);
  }
 
  virtual Model::BatchImportEvidenceToAssessmentControlOutcome BatchImportEvidenceToAssessmentControl(
      const Model::BatchImportEvidenceToAssessmentControlRequest& request) const;
 
  template <typename BatchImportEvidenceToAssessmentControlRequestT = Model::BatchImportEvidenceToAssessmentControlRequest>
  Model::BatchImportEvidenceToAssessmentControlOutcomeCallable BatchImportEvidenceToAssessmentControlCallable(
      const BatchImportEvidenceToAssessmentControlRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::BatchImportEvidenceToAssessmentControl, request);
  }
 
  template <typename BatchImportEvidenceToAssessmentControlRequestT = Model::BatchImportEvidenceToAssessmentControlRequest>
  void BatchImportEvidenceToAssessmentControlAsync(const BatchImportEvidenceToAssessmentControlRequestT& request,
                                                   const BatchImportEvidenceToAssessmentControlResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::BatchImportEvidenceToAssessmentControl, request, handler, context);
  }
 
  virtual Model::CreateAssessmentOutcome CreateAssessment(const Model::CreateAssessmentRequest& request) const;
 
  template <typename CreateAssessmentRequestT = Model::CreateAssessmentRequest>
  Model::CreateAssessmentOutcomeCallable CreateAssessmentCallable(const CreateAssessmentRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::CreateAssessment, request);
  }
 
  template <typename CreateAssessmentRequestT = Model::CreateAssessmentRequest>
  void CreateAssessmentAsync(const CreateAssessmentRequestT& request, const CreateAssessmentResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::CreateAssessment, request, handler, context);
  }
 
  virtual Model::CreateAssessmentFrameworkOutcome CreateAssessmentFramework(const Model::CreateAssessmentFrameworkRequest& request) const;
 
  template <typename CreateAssessmentFrameworkRequestT = Model::CreateAssessmentFrameworkRequest>
  Model::CreateAssessmentFrameworkOutcomeCallable CreateAssessmentFrameworkCallable(
      const CreateAssessmentFrameworkRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::CreateAssessmentFramework, request);
  }
 
  template <typename CreateAssessmentFrameworkRequestT = Model::CreateAssessmentFrameworkRequest>
  void CreateAssessmentFrameworkAsync(const CreateAssessmentFrameworkRequestT& request,
                                      const CreateAssessmentFrameworkResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::CreateAssessmentFramework, request, handler, context);
  }
 
  virtual Model::CreateAssessmentReportOutcome CreateAssessmentReport(const Model::CreateAssessmentReportRequest& request) const;
 
  template <typename CreateAssessmentReportRequestT = Model::CreateAssessmentReportRequest>
  Model::CreateAssessmentReportOutcomeCallable CreateAssessmentReportCallable(const CreateAssessmentReportRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::CreateAssessmentReport, request);
  }
 
  template <typename CreateAssessmentReportRequestT = Model::CreateAssessmentReportRequest>
  void CreateAssessmentReportAsync(const CreateAssessmentReportRequestT& request,
                                   const CreateAssessmentReportResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::CreateAssessmentReport, request, handler, context);
  }
 
  virtual Model::CreateControlOutcome CreateControl(const Model::CreateControlRequest& request) const;
 
  template <typename CreateControlRequestT = Model::CreateControlRequest>
  Model::CreateControlOutcomeCallable CreateControlCallable(const CreateControlRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::CreateControl, request);
  }
 
  template <typename CreateControlRequestT = Model::CreateControlRequest>
  void CreateControlAsync(const CreateControlRequestT& request, const CreateControlResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::CreateControl, request, handler, context);
  }
 
  virtual Model::DeleteAssessmentOutcome DeleteAssessment(const Model::DeleteAssessmentRequest& request) const;
 
  template <typename DeleteAssessmentRequestT = Model::DeleteAssessmentRequest>
  Model::DeleteAssessmentOutcomeCallable DeleteAssessmentCallable(const DeleteAssessmentRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::DeleteAssessment, request);
  }
 
  template <typename DeleteAssessmentRequestT = Model::DeleteAssessmentRequest>
  void DeleteAssessmentAsync(const DeleteAssessmentRequestT& request, const DeleteAssessmentResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::DeleteAssessment, request, handler, context);
  }
 
  virtual Model::DeleteAssessmentFrameworkOutcome DeleteAssessmentFramework(const Model::DeleteAssessmentFrameworkRequest& request) const;
 
  template <typename DeleteAssessmentFrameworkRequestT = Model::DeleteAssessmentFrameworkRequest>
  Model::DeleteAssessmentFrameworkOutcomeCallable DeleteAssessmentFrameworkCallable(
      const DeleteAssessmentFrameworkRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::DeleteAssessmentFramework, request);
  }
 
  template <typename DeleteAssessmentFrameworkRequestT = Model::DeleteAssessmentFrameworkRequest>
  void DeleteAssessmentFrameworkAsync(const DeleteAssessmentFrameworkRequestT& request,
                                      const DeleteAssessmentFrameworkResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::DeleteAssessmentFramework, request, handler, context);
  }
 
  virtual Model::DeleteAssessmentFrameworkShareOutcome DeleteAssessmentFrameworkShare(
      const Model::DeleteAssessmentFrameworkShareRequest& request) const;
 
  template <typename DeleteAssessmentFrameworkShareRequestT = Model::DeleteAssessmentFrameworkShareRequest>
  Model::DeleteAssessmentFrameworkShareOutcomeCallable DeleteAssessmentFrameworkShareCallable(
      const DeleteAssessmentFrameworkShareRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::DeleteAssessmentFrameworkShare, request);
  }
 
  template <typename DeleteAssessmentFrameworkShareRequestT = Model::DeleteAssessmentFrameworkShareRequest>
  void DeleteAssessmentFrameworkShareAsync(const DeleteAssessmentFrameworkShareRequestT& request,
                                           const DeleteAssessmentFrameworkShareResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::DeleteAssessmentFrameworkShare, request, handler, context);
  }
 
  virtual Model::DeleteAssessmentReportOutcome DeleteAssessmentReport(const Model::DeleteAssessmentReportRequest& request) const;
 
  template <typename DeleteAssessmentReportRequestT = Model::DeleteAssessmentReportRequest>
  Model::DeleteAssessmentReportOutcomeCallable DeleteAssessmentReportCallable(const DeleteAssessmentReportRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::DeleteAssessmentReport, request);
  }
 
  template <typename DeleteAssessmentReportRequestT = Model::DeleteAssessmentReportRequest>
  void DeleteAssessmentReportAsync(const DeleteAssessmentReportRequestT& request,
                                   const DeleteAssessmentReportResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::DeleteAssessmentReport, request, handler, context);
  }
 
  virtual Model::DeleteControlOutcome DeleteControl(const Model::DeleteControlRequest& request) const;
 
  template <typename DeleteControlRequestT = Model::DeleteControlRequest>
  Model::DeleteControlOutcomeCallable DeleteControlCallable(const DeleteControlRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::DeleteControl, request);
  }
 
  template <typename DeleteControlRequestT = Model::DeleteControlRequest>
  void DeleteControlAsync(const DeleteControlRequestT& request, const DeleteControlResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::DeleteControl, request, handler, context);
  }
 
  virtual Model::DeregisterAccountOutcome DeregisterAccount(const Model::DeregisterAccountRequest& request = {}) const;
 
  template <typename DeregisterAccountRequestT = Model::DeregisterAccountRequest>
  Model::DeregisterAccountOutcomeCallable DeregisterAccountCallable(const DeregisterAccountRequestT& request = {}) const {
    return SubmitCallable(&AuditManagerClient::DeregisterAccount, request);
  }
 
  template <typename DeregisterAccountRequestT = Model::DeregisterAccountRequest>
  void DeregisterAccountAsync(const DeregisterAccountResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const DeregisterAccountRequestT& request = {}) const {
    return SubmitAsync(&AuditManagerClient::DeregisterAccount, request, handler, context);
  }
 
  virtual Model::DeregisterOrganizationAdminAccountOutcome DeregisterOrganizationAdminAccount(
      const Model::DeregisterOrganizationAdminAccountRequest& request = {}) const;
 
  template <typename DeregisterOrganizationAdminAccountRequestT = Model::DeregisterOrganizationAdminAccountRequest>
  Model::DeregisterOrganizationAdminAccountOutcomeCallable DeregisterOrganizationAdminAccountCallable(
      const DeregisterOrganizationAdminAccountRequestT& request = {}) const {
    return SubmitCallable(&AuditManagerClient::DeregisterOrganizationAdminAccount, request);
  }
 
  template <typename DeregisterOrganizationAdminAccountRequestT = Model::DeregisterOrganizationAdminAccountRequest>
  void DeregisterOrganizationAdminAccountAsync(const DeregisterOrganizationAdminAccountResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DeregisterOrganizationAdminAccountRequestT& request = {}) const {
    return SubmitAsync(&AuditManagerClient::DeregisterOrganizationAdminAccount, request, handler, context);
  }
 
  virtual Model::DisassociateAssessmentReportEvidenceFolderOutcome DisassociateAssessmentReportEvidenceFolder(
      const Model::DisassociateAssessmentReportEvidenceFolderRequest& request) const;
 
  template <typename DisassociateAssessmentReportEvidenceFolderRequestT = Model::DisassociateAssessmentReportEvidenceFolderRequest>
  Model::DisassociateAssessmentReportEvidenceFolderOutcomeCallable DisassociateAssessmentReportEvidenceFolderCallable(
      const DisassociateAssessmentReportEvidenceFolderRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::DisassociateAssessmentReportEvidenceFolder, request);
  }
 
  template <typename DisassociateAssessmentReportEvidenceFolderRequestT = Model::DisassociateAssessmentReportEvidenceFolderRequest>
  void DisassociateAssessmentReportEvidenceFolderAsync(
      const DisassociateAssessmentReportEvidenceFolderRequestT& request,
      const DisassociateAssessmentReportEvidenceFolderResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::DisassociateAssessmentReportEvidenceFolder, request, handler, context);
  }
 
  virtual Model::GetAccountStatusOutcome GetAccountStatus(const Model::GetAccountStatusRequest& request = {}) const;
 
  template <typename GetAccountStatusRequestT = Model::GetAccountStatusRequest>
  Model::GetAccountStatusOutcomeCallable GetAccountStatusCallable(const GetAccountStatusRequestT& request = {}) const {
    return SubmitCallable(&AuditManagerClient::GetAccountStatus, request);
  }
 
  template <typename GetAccountStatusRequestT = Model::GetAccountStatusRequest>
  void GetAccountStatusAsync(const GetAccountStatusResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const GetAccountStatusRequestT& request = {}) const {
    return SubmitAsync(&AuditManagerClient::GetAccountStatus, request, handler, context);
  }
 
  virtual Model::GetAssessmentOutcome GetAssessment(const Model::GetAssessmentRequest& request) const;
 
  template <typename GetAssessmentRequestT = Model::GetAssessmentRequest>
  Model::GetAssessmentOutcomeCallable GetAssessmentCallable(const GetAssessmentRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::GetAssessment, request);
  }
 
  template <typename GetAssessmentRequestT = Model::GetAssessmentRequest>
  void GetAssessmentAsync(const GetAssessmentRequestT& request, const GetAssessmentResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::GetAssessment, request, handler, context);
  }
 
  virtual Model::GetAssessmentFrameworkOutcome GetAssessmentFramework(const Model::GetAssessmentFrameworkRequest& request) const;
 
  template <typename GetAssessmentFrameworkRequestT = Model::GetAssessmentFrameworkRequest>
  Model::GetAssessmentFrameworkOutcomeCallable GetAssessmentFrameworkCallable(const GetAssessmentFrameworkRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::GetAssessmentFramework, request);
  }
 
  template <typename GetAssessmentFrameworkRequestT = Model::GetAssessmentFrameworkRequest>
  void GetAssessmentFrameworkAsync(const GetAssessmentFrameworkRequestT& request,
                                   const GetAssessmentFrameworkResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::GetAssessmentFramework, request, handler, context);
  }
 
  virtual Model::GetAssessmentReportUrlOutcome GetAssessmentReportUrl(const Model::GetAssessmentReportUrlRequest& request) const;
 
  template <typename GetAssessmentReportUrlRequestT = Model::GetAssessmentReportUrlRequest>
  Model::GetAssessmentReportUrlOutcomeCallable GetAssessmentReportUrlCallable(const GetAssessmentReportUrlRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::GetAssessmentReportUrl, request);
  }
 
  template <typename GetAssessmentReportUrlRequestT = Model::GetAssessmentReportUrlRequest>
  void GetAssessmentReportUrlAsync(const GetAssessmentReportUrlRequestT& request,
                                   const GetAssessmentReportUrlResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::GetAssessmentReportUrl, request, handler, context);
  }
 
  virtual Model::GetChangeLogsOutcome GetChangeLogs(const Model::GetChangeLogsRequest& request) const;
 
  template <typename GetChangeLogsRequestT = Model::GetChangeLogsRequest>
  Model::GetChangeLogsOutcomeCallable GetChangeLogsCallable(const GetChangeLogsRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::GetChangeLogs, request);
  }
 
  template <typename GetChangeLogsRequestT = Model::GetChangeLogsRequest>
  void GetChangeLogsAsync(const GetChangeLogsRequestT& request, const GetChangeLogsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::GetChangeLogs, request, handler, context);
  }
 
  virtual Model::GetControlOutcome GetControl(const Model::GetControlRequest& request) const;
 
  template <typename GetControlRequestT = Model::GetControlRequest>
  Model::GetControlOutcomeCallable GetControlCallable(const GetControlRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::GetControl, request);
  }
 
  template <typename GetControlRequestT = Model::GetControlRequest>
  void GetControlAsync(const GetControlRequestT& request, const GetControlResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::GetControl, request, handler, context);
  }
 
  virtual Model::GetDelegationsOutcome GetDelegations(const Model::GetDelegationsRequest& request = {}) const;
 
  template <typename GetDelegationsRequestT = Model::GetDelegationsRequest>
  Model::GetDelegationsOutcomeCallable GetDelegationsCallable(const GetDelegationsRequestT& request = {}) const {
    return SubmitCallable(&AuditManagerClient::GetDelegations, request);
  }
 
  template <typename GetDelegationsRequestT = Model::GetDelegationsRequest>
  void GetDelegationsAsync(const GetDelegationsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const GetDelegationsRequestT& request = {}) const {
    return SubmitAsync(&AuditManagerClient::GetDelegations, request, handler, context);
  }
 
  virtual Model::GetEvidenceOutcome GetEvidence(const Model::GetEvidenceRequest& request) const;
 
  template <typename GetEvidenceRequestT = Model::GetEvidenceRequest>
  Model::GetEvidenceOutcomeCallable GetEvidenceCallable(const GetEvidenceRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::GetEvidence, request);
  }
 
  template <typename GetEvidenceRequestT = Model::GetEvidenceRequest>
  void GetEvidenceAsync(const GetEvidenceRequestT& request, const GetEvidenceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::GetEvidence, request, handler, context);
  }
 
  virtual Model::GetEvidenceByEvidenceFolderOutcome GetEvidenceByEvidenceFolder(
      const Model::GetEvidenceByEvidenceFolderRequest& request) const;
 
  template <typename GetEvidenceByEvidenceFolderRequestT = Model::GetEvidenceByEvidenceFolderRequest>
  Model::GetEvidenceByEvidenceFolderOutcomeCallable GetEvidenceByEvidenceFolderCallable(
      const GetEvidenceByEvidenceFolderRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::GetEvidenceByEvidenceFolder, request);
  }
 
  template <typename GetEvidenceByEvidenceFolderRequestT = Model::GetEvidenceByEvidenceFolderRequest>
  void GetEvidenceByEvidenceFolderAsync(const GetEvidenceByEvidenceFolderRequestT& request,
                                        const GetEvidenceByEvidenceFolderResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::GetEvidenceByEvidenceFolder, request, handler, context);
  }
 
  virtual Model::GetEvidenceFileUploadUrlOutcome GetEvidenceFileUploadUrl(const Model::GetEvidenceFileUploadUrlRequest& request) const;
 
  template <typename GetEvidenceFileUploadUrlRequestT = Model::GetEvidenceFileUploadUrlRequest>
  Model::GetEvidenceFileUploadUrlOutcomeCallable GetEvidenceFileUploadUrlCallable(const GetEvidenceFileUploadUrlRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::GetEvidenceFileUploadUrl, request);
  }
 
  template <typename GetEvidenceFileUploadUrlRequestT = Model::GetEvidenceFileUploadUrlRequest>
  void GetEvidenceFileUploadUrlAsync(const GetEvidenceFileUploadUrlRequestT& request,
                                     const GetEvidenceFileUploadUrlResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::GetEvidenceFileUploadUrl, request, handler, context);
  }
 
  virtual Model::GetEvidenceFolderOutcome GetEvidenceFolder(const Model::GetEvidenceFolderRequest& request) const;
 
  template <typename GetEvidenceFolderRequestT = Model::GetEvidenceFolderRequest>
  Model::GetEvidenceFolderOutcomeCallable GetEvidenceFolderCallable(const GetEvidenceFolderRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::GetEvidenceFolder, request);
  }
 
  template <typename GetEvidenceFolderRequestT = Model::GetEvidenceFolderRequest>
  void GetEvidenceFolderAsync(const GetEvidenceFolderRequestT& request, const GetEvidenceFolderResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::GetEvidenceFolder, request, handler, context);
  }
 
  virtual Model::GetEvidenceFoldersByAssessmentOutcome GetEvidenceFoldersByAssessment(
      const Model::GetEvidenceFoldersByAssessmentRequest& request) const;
 
  template <typename GetEvidenceFoldersByAssessmentRequestT = Model::GetEvidenceFoldersByAssessmentRequest>
  Model::GetEvidenceFoldersByAssessmentOutcomeCallable GetEvidenceFoldersByAssessmentCallable(
      const GetEvidenceFoldersByAssessmentRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::GetEvidenceFoldersByAssessment, request);
  }
 
  template <typename GetEvidenceFoldersByAssessmentRequestT = Model::GetEvidenceFoldersByAssessmentRequest>
  void GetEvidenceFoldersByAssessmentAsync(const GetEvidenceFoldersByAssessmentRequestT& request,
                                           const GetEvidenceFoldersByAssessmentResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::GetEvidenceFoldersByAssessment, request, handler, context);
  }
 
  virtual Model::GetEvidenceFoldersByAssessmentControlOutcome GetEvidenceFoldersByAssessmentControl(
      const Model::GetEvidenceFoldersByAssessmentControlRequest& request) const;
 
  template <typename GetEvidenceFoldersByAssessmentControlRequestT = Model::GetEvidenceFoldersByAssessmentControlRequest>
  Model::GetEvidenceFoldersByAssessmentControlOutcomeCallable GetEvidenceFoldersByAssessmentControlCallable(
      const GetEvidenceFoldersByAssessmentControlRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::GetEvidenceFoldersByAssessmentControl, request);
  }
 
  template <typename GetEvidenceFoldersByAssessmentControlRequestT = Model::GetEvidenceFoldersByAssessmentControlRequest>
  void GetEvidenceFoldersByAssessmentControlAsync(const GetEvidenceFoldersByAssessmentControlRequestT& request,
                                                  const GetEvidenceFoldersByAssessmentControlResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::GetEvidenceFoldersByAssessmentControl, request, handler, context);
  }
 
  virtual Model::GetInsightsOutcome GetInsights(const Model::GetInsightsRequest& request = {}) const;
 
  template <typename GetInsightsRequestT = Model::GetInsightsRequest>
  Model::GetInsightsOutcomeCallable GetInsightsCallable(const GetInsightsRequestT& request = {}) const {
    return SubmitCallable(&AuditManagerClient::GetInsights, request);
  }
 
  template <typename GetInsightsRequestT = Model::GetInsightsRequest>
  void GetInsightsAsync(const GetInsightsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const GetInsightsRequestT& request = {}) const {
    return SubmitAsync(&AuditManagerClient::GetInsights, request, handler, context);
  }
 
  virtual Model::GetInsightsByAssessmentOutcome GetInsightsByAssessment(const Model::GetInsightsByAssessmentRequest& request) const;
 
  template <typename GetInsightsByAssessmentRequestT = Model::GetInsightsByAssessmentRequest>
  Model::GetInsightsByAssessmentOutcomeCallable GetInsightsByAssessmentCallable(const GetInsightsByAssessmentRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::GetInsightsByAssessment, request);
  }
 
  template <typename GetInsightsByAssessmentRequestT = Model::GetInsightsByAssessmentRequest>
  void GetInsightsByAssessmentAsync(const GetInsightsByAssessmentRequestT& request,
                                    const GetInsightsByAssessmentResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::GetInsightsByAssessment, request, handler, context);
  }
 
  virtual Model::GetOrganizationAdminAccountOutcome GetOrganizationAdminAccount(
      const Model::GetOrganizationAdminAccountRequest& request = {}) const;
 
  template <typename GetOrganizationAdminAccountRequestT = Model::GetOrganizationAdminAccountRequest>
  Model::GetOrganizationAdminAccountOutcomeCallable GetOrganizationAdminAccountCallable(
      const GetOrganizationAdminAccountRequestT& request = {}) const {
    return SubmitCallable(&AuditManagerClient::GetOrganizationAdminAccount, request);
  }
 
  template <typename GetOrganizationAdminAccountRequestT = Model::GetOrganizationAdminAccountRequest>
  void GetOrganizationAdminAccountAsync(const GetOrganizationAdminAccountResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const GetOrganizationAdminAccountRequestT& request = {}) const {
    return SubmitAsync(&AuditManagerClient::GetOrganizationAdminAccount, request, handler, context);
  }
 
  virtual Model::GetServicesInScopeOutcome GetServicesInScope(const Model::GetServicesInScopeRequest& request = {}) const;
 
  template <typename GetServicesInScopeRequestT = Model::GetServicesInScopeRequest>
  Model::GetServicesInScopeOutcomeCallable GetServicesInScopeCallable(const GetServicesInScopeRequestT& request = {}) const {
    return SubmitCallable(&AuditManagerClient::GetServicesInScope, request);
  }
 
  template <typename GetServicesInScopeRequestT = Model::GetServicesInScopeRequest>
  void GetServicesInScopeAsync(const GetServicesInScopeResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const GetServicesInScopeRequestT& request = {}) const {
    return SubmitAsync(&AuditManagerClient::GetServicesInScope, request, handler, context);
  }
 
  virtual Model::GetSettingsOutcome GetSettings(const Model::GetSettingsRequest& request) const;
 
  template <typename GetSettingsRequestT = Model::GetSettingsRequest>
  Model::GetSettingsOutcomeCallable GetSettingsCallable(const GetSettingsRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::GetSettings, request);
  }
 
  template <typename GetSettingsRequestT = Model::GetSettingsRequest>
  void GetSettingsAsync(const GetSettingsRequestT& request, const GetSettingsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::GetSettings, request, handler, context);
  }
 
  virtual Model::ListAssessmentControlInsightsByControlDomainOutcome ListAssessmentControlInsightsByControlDomain(
      const Model::ListAssessmentControlInsightsByControlDomainRequest& request) const;
 
  template <typename ListAssessmentControlInsightsByControlDomainRequestT = Model::ListAssessmentControlInsightsByControlDomainRequest>
  Model::ListAssessmentControlInsightsByControlDomainOutcomeCallable ListAssessmentControlInsightsByControlDomainCallable(
      const ListAssessmentControlInsightsByControlDomainRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::ListAssessmentControlInsightsByControlDomain, request);
  }
 
  template <typename ListAssessmentControlInsightsByControlDomainRequestT = Model::ListAssessmentControlInsightsByControlDomainRequest>
  void ListAssessmentControlInsightsByControlDomainAsync(
      const ListAssessmentControlInsightsByControlDomainRequestT& request,
      const ListAssessmentControlInsightsByControlDomainResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::ListAssessmentControlInsightsByControlDomain, request, handler, context);
  }
 
  virtual Model::ListAssessmentFrameworkShareRequestsOutcome ListAssessmentFrameworkShareRequests(
      const Model::ListAssessmentFrameworkShareRequestsRequest& request) const;
 
  template <typename ListAssessmentFrameworkShareRequestsRequestT = Model::ListAssessmentFrameworkShareRequestsRequest>
  Model::ListAssessmentFrameworkShareRequestsOutcomeCallable ListAssessmentFrameworkShareRequestsCallable(
      const ListAssessmentFrameworkShareRequestsRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::ListAssessmentFrameworkShareRequests, request);
  }
 
  template <typename ListAssessmentFrameworkShareRequestsRequestT = Model::ListAssessmentFrameworkShareRequestsRequest>
  void ListAssessmentFrameworkShareRequestsAsync(const ListAssessmentFrameworkShareRequestsRequestT& request,
                                                 const ListAssessmentFrameworkShareRequestsResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::ListAssessmentFrameworkShareRequests, request, handler, context);
  }
 
  virtual Model::ListAssessmentFrameworksOutcome ListAssessmentFrameworks(const Model::ListAssessmentFrameworksRequest& request) const;
 
  template <typename ListAssessmentFrameworksRequestT = Model::ListAssessmentFrameworksRequest>
  Model::ListAssessmentFrameworksOutcomeCallable ListAssessmentFrameworksCallable(const ListAssessmentFrameworksRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::ListAssessmentFrameworks, request);
  }
 
  template <typename ListAssessmentFrameworksRequestT = Model::ListAssessmentFrameworksRequest>
  void ListAssessmentFrameworksAsync(const ListAssessmentFrameworksRequestT& request,
                                     const ListAssessmentFrameworksResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::ListAssessmentFrameworks, request, handler, context);
  }
 
  virtual Model::ListAssessmentReportsOutcome ListAssessmentReports(const Model::ListAssessmentReportsRequest& request = {}) const;
 
  template <typename ListAssessmentReportsRequestT = Model::ListAssessmentReportsRequest>
  Model::ListAssessmentReportsOutcomeCallable ListAssessmentReportsCallable(const ListAssessmentReportsRequestT& request = {}) const {
    return SubmitCallable(&AuditManagerClient::ListAssessmentReports, request);
  }
 
  template <typename ListAssessmentReportsRequestT = Model::ListAssessmentReportsRequest>
  void ListAssessmentReportsAsync(const ListAssessmentReportsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListAssessmentReportsRequestT& request = {}) const {
    return SubmitAsync(&AuditManagerClient::ListAssessmentReports, request, handler, context);
  }
 
  virtual Model::ListAssessmentsOutcome ListAssessments(const Model::ListAssessmentsRequest& request = {}) const;
 
  template <typename ListAssessmentsRequestT = Model::ListAssessmentsRequest>
  Model::ListAssessmentsOutcomeCallable ListAssessmentsCallable(const ListAssessmentsRequestT& request = {}) const {
    return SubmitCallable(&AuditManagerClient::ListAssessments, request);
  }
 
  template <typename ListAssessmentsRequestT = Model::ListAssessmentsRequest>
  void ListAssessmentsAsync(const ListAssessmentsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListAssessmentsRequestT& request = {}) const {
    return SubmitAsync(&AuditManagerClient::ListAssessments, request, handler, context);
  }
 
  virtual Model::ListControlDomainInsightsOutcome ListControlDomainInsights(
      const Model::ListControlDomainInsightsRequest& request = {}) const;
 
  template <typename ListControlDomainInsightsRequestT = Model::ListControlDomainInsightsRequest>
  Model::ListControlDomainInsightsOutcomeCallable ListControlDomainInsightsCallable(
      const ListControlDomainInsightsRequestT& request = {}) const {
    return SubmitCallable(&AuditManagerClient::ListControlDomainInsights, request);
  }
 
  template <typename ListControlDomainInsightsRequestT = Model::ListControlDomainInsightsRequest>
  void ListControlDomainInsightsAsync(const ListControlDomainInsightsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListControlDomainInsightsRequestT& request = {}) const {
    return SubmitAsync(&AuditManagerClient::ListControlDomainInsights, request, handler, context);
  }
 
  virtual Model::ListControlDomainInsightsByAssessmentOutcome ListControlDomainInsightsByAssessment(
      const Model::ListControlDomainInsightsByAssessmentRequest& request) const;
 
  template <typename ListControlDomainInsightsByAssessmentRequestT = Model::ListControlDomainInsightsByAssessmentRequest>
  Model::ListControlDomainInsightsByAssessmentOutcomeCallable ListControlDomainInsightsByAssessmentCallable(
      const ListControlDomainInsightsByAssessmentRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::ListControlDomainInsightsByAssessment, request);
  }
 
  template <typename ListControlDomainInsightsByAssessmentRequestT = Model::ListControlDomainInsightsByAssessmentRequest>
  void ListControlDomainInsightsByAssessmentAsync(const ListControlDomainInsightsByAssessmentRequestT& request,
                                                  const ListControlDomainInsightsByAssessmentResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::ListControlDomainInsightsByAssessment, request, handler, context);
  }
 
  virtual Model::ListControlInsightsByControlDomainOutcome ListControlInsightsByControlDomain(
      const Model::ListControlInsightsByControlDomainRequest& request) const;
 
  template <typename ListControlInsightsByControlDomainRequestT = Model::ListControlInsightsByControlDomainRequest>
  Model::ListControlInsightsByControlDomainOutcomeCallable ListControlInsightsByControlDomainCallable(
      const ListControlInsightsByControlDomainRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::ListControlInsightsByControlDomain, request);
  }
 
  template <typename ListControlInsightsByControlDomainRequestT = Model::ListControlInsightsByControlDomainRequest>
  void ListControlInsightsByControlDomainAsync(const ListControlInsightsByControlDomainRequestT& request,
                                               const ListControlInsightsByControlDomainResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::ListControlInsightsByControlDomain, request, handler, context);
  }
 
  virtual Model::ListControlsOutcome ListControls(const Model::ListControlsRequest& request) const;
 
  template <typename ListControlsRequestT = Model::ListControlsRequest>
  Model::ListControlsOutcomeCallable ListControlsCallable(const ListControlsRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::ListControls, request);
  }
 
  template <typename ListControlsRequestT = Model::ListControlsRequest>
  void ListControlsAsync(const ListControlsRequestT& request, const ListControlsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::ListControls, request, handler, context);
  }
 
  virtual Model::ListKeywordsForDataSourceOutcome ListKeywordsForDataSource(const Model::ListKeywordsForDataSourceRequest& request) const;
 
  template <typename ListKeywordsForDataSourceRequestT = Model::ListKeywordsForDataSourceRequest>
  Model::ListKeywordsForDataSourceOutcomeCallable ListKeywordsForDataSourceCallable(
      const ListKeywordsForDataSourceRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::ListKeywordsForDataSource, request);
  }
 
  template <typename ListKeywordsForDataSourceRequestT = Model::ListKeywordsForDataSourceRequest>
  void ListKeywordsForDataSourceAsync(const ListKeywordsForDataSourceRequestT& request,
                                      const ListKeywordsForDataSourceResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::ListKeywordsForDataSource, request, handler, context);
  }
 
  virtual Model::ListNotificationsOutcome ListNotifications(const Model::ListNotificationsRequest& request = {}) const;
 
  template <typename ListNotificationsRequestT = Model::ListNotificationsRequest>
  Model::ListNotificationsOutcomeCallable ListNotificationsCallable(const ListNotificationsRequestT& request = {}) const {
    return SubmitCallable(&AuditManagerClient::ListNotifications, request);
  }
 
  template <typename ListNotificationsRequestT = Model::ListNotificationsRequest>
  void ListNotificationsAsync(const ListNotificationsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListNotificationsRequestT& request = {}) const {
    return SubmitAsync(&AuditManagerClient::ListNotifications, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RegisterAccountOutcome RegisterAccount(const Model::RegisterAccountRequest& request = {}) const;
 
  template <typename RegisterAccountRequestT = Model::RegisterAccountRequest>
  Model::RegisterAccountOutcomeCallable RegisterAccountCallable(const RegisterAccountRequestT& request = {}) const {
    return SubmitCallable(&AuditManagerClient::RegisterAccount, request);
  }
 
  template <typename RegisterAccountRequestT = Model::RegisterAccountRequest>
  void RegisterAccountAsync(const RegisterAccountResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const RegisterAccountRequestT& request = {}) const {
    return SubmitAsync(&AuditManagerClient::RegisterAccount, request, handler, context);
  }
 
  virtual Model::RegisterOrganizationAdminAccountOutcome RegisterOrganizationAdminAccount(
      const Model::RegisterOrganizationAdminAccountRequest& request) const;
 
  template <typename RegisterOrganizationAdminAccountRequestT = Model::RegisterOrganizationAdminAccountRequest>
  Model::RegisterOrganizationAdminAccountOutcomeCallable RegisterOrganizationAdminAccountCallable(
      const RegisterOrganizationAdminAccountRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::RegisterOrganizationAdminAccount, request);
  }
 
  template <typename RegisterOrganizationAdminAccountRequestT = Model::RegisterOrganizationAdminAccountRequest>
  void RegisterOrganizationAdminAccountAsync(const RegisterOrganizationAdminAccountRequestT& request,
                                             const RegisterOrganizationAdminAccountResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::RegisterOrganizationAdminAccount, request, handler, context);
  }
 
  virtual Model::StartAssessmentFrameworkShareOutcome StartAssessmentFrameworkShare(
      const Model::StartAssessmentFrameworkShareRequest& request) const;
 
  template <typename StartAssessmentFrameworkShareRequestT = Model::StartAssessmentFrameworkShareRequest>
  Model::StartAssessmentFrameworkShareOutcomeCallable StartAssessmentFrameworkShareCallable(
      const StartAssessmentFrameworkShareRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::StartAssessmentFrameworkShare, request);
  }
 
  template <typename StartAssessmentFrameworkShareRequestT = Model::StartAssessmentFrameworkShareRequest>
  void StartAssessmentFrameworkShareAsync(const StartAssessmentFrameworkShareRequestT& request,
                                          const StartAssessmentFrameworkShareResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::StartAssessmentFrameworkShare, 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(&AuditManagerClient::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(&AuditManagerClient::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(&AuditManagerClient::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(&AuditManagerClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAssessmentOutcome UpdateAssessment(const Model::UpdateAssessmentRequest& request) const;
 
  template <typename UpdateAssessmentRequestT = Model::UpdateAssessmentRequest>
  Model::UpdateAssessmentOutcomeCallable UpdateAssessmentCallable(const UpdateAssessmentRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::UpdateAssessment, request);
  }
 
  template <typename UpdateAssessmentRequestT = Model::UpdateAssessmentRequest>
  void UpdateAssessmentAsync(const UpdateAssessmentRequestT& request, const UpdateAssessmentResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::UpdateAssessment, request, handler, context);
  }
 
  virtual Model::UpdateAssessmentControlOutcome UpdateAssessmentControl(const Model::UpdateAssessmentControlRequest& request) const;
 
  template <typename UpdateAssessmentControlRequestT = Model::UpdateAssessmentControlRequest>
  Model::UpdateAssessmentControlOutcomeCallable UpdateAssessmentControlCallable(const UpdateAssessmentControlRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::UpdateAssessmentControl, request);
  }
 
  template <typename UpdateAssessmentControlRequestT = Model::UpdateAssessmentControlRequest>
  void UpdateAssessmentControlAsync(const UpdateAssessmentControlRequestT& request,
                                    const UpdateAssessmentControlResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::UpdateAssessmentControl, request, handler, context);
  }
 
  virtual Model::UpdateAssessmentControlSetStatusOutcome UpdateAssessmentControlSetStatus(
      const Model::UpdateAssessmentControlSetStatusRequest& request) const;
 
  template <typename UpdateAssessmentControlSetStatusRequestT = Model::UpdateAssessmentControlSetStatusRequest>
  Model::UpdateAssessmentControlSetStatusOutcomeCallable UpdateAssessmentControlSetStatusCallable(
      const UpdateAssessmentControlSetStatusRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::UpdateAssessmentControlSetStatus, request);
  }
 
  template <typename UpdateAssessmentControlSetStatusRequestT = Model::UpdateAssessmentControlSetStatusRequest>
  void UpdateAssessmentControlSetStatusAsync(const UpdateAssessmentControlSetStatusRequestT& request,
                                             const UpdateAssessmentControlSetStatusResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::UpdateAssessmentControlSetStatus, request, handler, context);
  }
 
  virtual Model::UpdateAssessmentFrameworkOutcome UpdateAssessmentFramework(const Model::UpdateAssessmentFrameworkRequest& request) const;
 
  template <typename UpdateAssessmentFrameworkRequestT = Model::UpdateAssessmentFrameworkRequest>
  Model::UpdateAssessmentFrameworkOutcomeCallable UpdateAssessmentFrameworkCallable(
      const UpdateAssessmentFrameworkRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::UpdateAssessmentFramework, request);
  }
 
  template <typename UpdateAssessmentFrameworkRequestT = Model::UpdateAssessmentFrameworkRequest>
  void UpdateAssessmentFrameworkAsync(const UpdateAssessmentFrameworkRequestT& request,
                                      const UpdateAssessmentFrameworkResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::UpdateAssessmentFramework, request, handler, context);
  }
 
  virtual Model::UpdateAssessmentFrameworkShareOutcome UpdateAssessmentFrameworkShare(
      const Model::UpdateAssessmentFrameworkShareRequest& request) const;
 
  template <typename UpdateAssessmentFrameworkShareRequestT = Model::UpdateAssessmentFrameworkShareRequest>
  Model::UpdateAssessmentFrameworkShareOutcomeCallable UpdateAssessmentFrameworkShareCallable(
      const UpdateAssessmentFrameworkShareRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::UpdateAssessmentFrameworkShare, request);
  }
 
  template <typename UpdateAssessmentFrameworkShareRequestT = Model::UpdateAssessmentFrameworkShareRequest>
  void UpdateAssessmentFrameworkShareAsync(const UpdateAssessmentFrameworkShareRequestT& request,
                                           const UpdateAssessmentFrameworkShareResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::UpdateAssessmentFrameworkShare, request, handler, context);
  }
 
  virtual Model::UpdateAssessmentStatusOutcome UpdateAssessmentStatus(const Model::UpdateAssessmentStatusRequest& request) const;
 
  template <typename UpdateAssessmentStatusRequestT = Model::UpdateAssessmentStatusRequest>
  Model::UpdateAssessmentStatusOutcomeCallable UpdateAssessmentStatusCallable(const UpdateAssessmentStatusRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::UpdateAssessmentStatus, request);
  }
 
  template <typename UpdateAssessmentStatusRequestT = Model::UpdateAssessmentStatusRequest>
  void UpdateAssessmentStatusAsync(const UpdateAssessmentStatusRequestT& request,
                                   const UpdateAssessmentStatusResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::UpdateAssessmentStatus, request, handler, context);
  }
 
  virtual Model::UpdateControlOutcome UpdateControl(const Model::UpdateControlRequest& request) const;
 
  template <typename UpdateControlRequestT = Model::UpdateControlRequest>
  Model::UpdateControlOutcomeCallable UpdateControlCallable(const UpdateControlRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::UpdateControl, request);
  }
 
  template <typename UpdateControlRequestT = Model::UpdateControlRequest>
  void UpdateControlAsync(const UpdateControlRequestT& request, const UpdateControlResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::UpdateControl, request, handler, context);
  }
 
  virtual Model::UpdateSettingsOutcome UpdateSettings(const Model::UpdateSettingsRequest& request = {}) const;
 
  template <typename UpdateSettingsRequestT = Model::UpdateSettingsRequest>
  Model::UpdateSettingsOutcomeCallable UpdateSettingsCallable(const UpdateSettingsRequestT& request = {}) const {
    return SubmitCallable(&AuditManagerClient::UpdateSettings, request);
  }
 
  template <typename UpdateSettingsRequestT = Model::UpdateSettingsRequest>
  void UpdateSettingsAsync(const UpdateSettingsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const UpdateSettingsRequestT& request = {}) const {
    return SubmitAsync(&AuditManagerClient::UpdateSettings, request, handler, context);
  }
 
  virtual Model::ValidateAssessmentReportIntegrityOutcome ValidateAssessmentReportIntegrity(
      const Model::ValidateAssessmentReportIntegrityRequest& request) const;
 
  template <typename ValidateAssessmentReportIntegrityRequestT = Model::ValidateAssessmentReportIntegrityRequest>
  Model::ValidateAssessmentReportIntegrityOutcomeCallable ValidateAssessmentReportIntegrityCallable(
      const ValidateAssessmentReportIntegrityRequestT& request) const {
    return SubmitCallable(&AuditManagerClient::ValidateAssessmentReportIntegrity, request);
  }
 
  template <typename ValidateAssessmentReportIntegrityRequestT = Model::ValidateAssessmentReportIntegrityRequest>
  void ValidateAssessmentReportIntegrityAsync(const ValidateAssessmentReportIntegrityRequestT& request,
                                              const ValidateAssessmentReportIntegrityResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AuditManagerClient::ValidateAssessmentReportIntegrity, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<AuditManagerEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AuditManagerClient>;
  void init(const AuditManagerClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, AuditManagerError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  AuditManagerClientConfiguration m_clientConfiguration;
  std::shared_ptr<AuditManagerEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace AuditManager
}  // namespace Aws