AuditManagerClient.h

 
#pragma once
#include <aws/auditmanager/AuditManager_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/auditmanager/AuditManagerServiceClientModel.h>
 
namespace Aws
{
namespace AuditManager
{
  class AWS_AUDITMANAGER_API AuditManagerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<AuditManagerEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<AuditManagerClient>;
      void init(const AuditManagerClientConfiguration& clientConfiguration);
 
      AuditManagerClientConfiguration m_clientConfiguration;
      std::shared_ptr<AuditManagerEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace AuditManager
} // namespace Aws