/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace AuditManager { /** *

Welcome to the Audit Manager API reference. This guide is for developers who * need detailed information about the Audit Manager API operations, data types, * and errors.

Audit Manager is a service that provides automated evidence * collection so that you can continually audit your Amazon Web Services usage. You * can use it to assess the effectiveness of your controls, manage risk, and * simplify compliance.

Audit Manager provides prebuilt frameworks that * structure and automate assessments for a given compliance standard. Frameworks * include a prebuilt collection of controls with descriptions and testing * procedures. These controls are grouped according to the requirements of the * specified compliance standard or regulation. You can also customize frameworks * and controls to support internal audits with specific requirements.

Use * the following links to get started with the Audit Manager API:

  • * Actions: * An alphabetical list of all Audit Manager API operations.

  • Data * types: An alphabetical list of all Audit Manager data types.

  • *

    Common * parameters: Parameters that all operations can use.

  • Common * errors: Client and server errors that all operations can return.

    • *

If you're new to Audit Manager, we recommend that you review the * Audit Manager User Guide.

*/ class AWS_AUDITMANAGER_API AuditManagerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef AuditManagerClientConfiguration ClientConfigurationType; typedef AuditManagerEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ AuditManagerClient(const Aws::AuditManager::AuditManagerClientConfiguration& clientConfiguration = Aws::AuditManager::AuditManagerClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ AuditManagerClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::AuditManager::AuditManagerClientConfiguration& clientConfiguration = Aws::AuditManager::AuditManagerClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ AuditManagerClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::AuditManager::AuditManagerClientConfiguration& clientConfiguration = Aws::AuditManager::AuditManagerClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ AuditManagerClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ AuditManagerClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ AuditManagerClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~AuditManagerClient(); /** *

Associates an evidence folder to an assessment report in an Audit Manager * assessment.

See Also:

AWS * API Reference

*/ virtual Model::AssociateAssessmentReportEvidenceFolderOutcome AssociateAssessmentReportEvidenceFolder(const Model::AssociateAssessmentReportEvidenceFolderRequest& request) const; /** * A Callable wrapper for AssociateAssessmentReportEvidenceFolder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateAssessmentReportEvidenceFolderOutcomeCallable AssociateAssessmentReportEvidenceFolderCallable(const AssociateAssessmentReportEvidenceFolderRequestT& request) const { return SubmitCallable(&AuditManagerClient::AssociateAssessmentReportEvidenceFolder, request); } /** * An Async wrapper for AssociateAssessmentReportEvidenceFolder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateAssessmentReportEvidenceFolderAsync(const AssociateAssessmentReportEvidenceFolderRequestT& request, const AssociateAssessmentReportEvidenceFolderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::AssociateAssessmentReportEvidenceFolder, request, handler, context); } /** *

Associates a list of evidence to an assessment report in an Audit Manager * assessment.

See Also:

AWS * API Reference

*/ virtual Model::BatchAssociateAssessmentReportEvidenceOutcome BatchAssociateAssessmentReportEvidence(const Model::BatchAssociateAssessmentReportEvidenceRequest& request) const; /** * A Callable wrapper for BatchAssociateAssessmentReportEvidence that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchAssociateAssessmentReportEvidenceOutcomeCallable BatchAssociateAssessmentReportEvidenceCallable(const BatchAssociateAssessmentReportEvidenceRequestT& request) const { return SubmitCallable(&AuditManagerClient::BatchAssociateAssessmentReportEvidence, request); } /** * An Async wrapper for BatchAssociateAssessmentReportEvidence that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchAssociateAssessmentReportEvidenceAsync(const BatchAssociateAssessmentReportEvidenceRequestT& request, const BatchAssociateAssessmentReportEvidenceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::BatchAssociateAssessmentReportEvidence, request, handler, context); } /** *

Creates a batch of delegations for an assessment in Audit Manager. *

See Also:

AWS * API Reference

*/ virtual Model::BatchCreateDelegationByAssessmentOutcome BatchCreateDelegationByAssessment(const Model::BatchCreateDelegationByAssessmentRequest& request) const; /** * A Callable wrapper for BatchCreateDelegationByAssessment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchCreateDelegationByAssessmentOutcomeCallable BatchCreateDelegationByAssessmentCallable(const BatchCreateDelegationByAssessmentRequestT& request) const { return SubmitCallable(&AuditManagerClient::BatchCreateDelegationByAssessment, request); } /** * An Async wrapper for BatchCreateDelegationByAssessment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchCreateDelegationByAssessmentAsync(const BatchCreateDelegationByAssessmentRequestT& request, const BatchCreateDelegationByAssessmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::BatchCreateDelegationByAssessment, request, handler, context); } /** *

Deletes a batch of delegations for an assessment in Audit Manager. *

See Also:

AWS * API Reference

*/ virtual Model::BatchDeleteDelegationByAssessmentOutcome BatchDeleteDelegationByAssessment(const Model::BatchDeleteDelegationByAssessmentRequest& request) const; /** * A Callable wrapper for BatchDeleteDelegationByAssessment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchDeleteDelegationByAssessmentOutcomeCallable BatchDeleteDelegationByAssessmentCallable(const BatchDeleteDelegationByAssessmentRequestT& request) const { return SubmitCallable(&AuditManagerClient::BatchDeleteDelegationByAssessment, request); } /** * An Async wrapper for BatchDeleteDelegationByAssessment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchDeleteDelegationByAssessmentAsync(const BatchDeleteDelegationByAssessmentRequestT& request, const BatchDeleteDelegationByAssessmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::BatchDeleteDelegationByAssessment, request, handler, context); } /** *

Disassociates a list of evidence from an assessment report in Audit Manager. *

See Also:

AWS * API Reference

*/ virtual Model::BatchDisassociateAssessmentReportEvidenceOutcome BatchDisassociateAssessmentReportEvidence(const Model::BatchDisassociateAssessmentReportEvidenceRequest& request) const; /** * A Callable wrapper for BatchDisassociateAssessmentReportEvidence that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchDisassociateAssessmentReportEvidenceOutcomeCallable BatchDisassociateAssessmentReportEvidenceCallable(const BatchDisassociateAssessmentReportEvidenceRequestT& request) const { return SubmitCallable(&AuditManagerClient::BatchDisassociateAssessmentReportEvidence, request); } /** * An Async wrapper for BatchDisassociateAssessmentReportEvidence that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchDisassociateAssessmentReportEvidenceAsync(const BatchDisassociateAssessmentReportEvidenceRequestT& request, const BatchDisassociateAssessmentReportEvidenceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::BatchDisassociateAssessmentReportEvidence, request, handler, context); } /** *

Adds one or more pieces of evidence to a control in an Audit Manager * assessment.

You can import manual evidence from any S3 bucket by * specifying the S3 URI of the object. You can also upload a file from your * browser, or enter plain text in response to a risk assessment question.

*

The following restrictions apply to this action:

  • * manualEvidence can be only one of the following: * evidenceFileName, s3ResourcePath, or * textResponse

  • Maximum size of an individual * evidence file: 100 MB

  • Number of daily manual evidence uploads * per control: 100

  • Supported file formats: See Supported * file types for manual evidence in the Audit Manager User Guide

    *

For more information about Audit Manager service restrictions, * see Quotas * and restrictions for Audit Manager.

See Also:

AWS * API Reference

*/ virtual Model::BatchImportEvidenceToAssessmentControlOutcome BatchImportEvidenceToAssessmentControl(const Model::BatchImportEvidenceToAssessmentControlRequest& request) const; /** * A Callable wrapper for BatchImportEvidenceToAssessmentControl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchImportEvidenceToAssessmentControlOutcomeCallable BatchImportEvidenceToAssessmentControlCallable(const BatchImportEvidenceToAssessmentControlRequestT& request) const { return SubmitCallable(&AuditManagerClient::BatchImportEvidenceToAssessmentControl, request); } /** * An Async wrapper for BatchImportEvidenceToAssessmentControl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchImportEvidenceToAssessmentControlAsync(const BatchImportEvidenceToAssessmentControlRequestT& request, const BatchImportEvidenceToAssessmentControlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::BatchImportEvidenceToAssessmentControl, request, handler, context); } /** *

Creates an assessment in Audit Manager.

See Also:

AWS * API Reference

*/ virtual Model::CreateAssessmentOutcome CreateAssessment(const Model::CreateAssessmentRequest& request) const; /** * A Callable wrapper for CreateAssessment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAssessmentOutcomeCallable CreateAssessmentCallable(const CreateAssessmentRequestT& request) const { return SubmitCallable(&AuditManagerClient::CreateAssessment, request); } /** * An Async wrapper for CreateAssessment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAssessmentAsync(const CreateAssessmentRequestT& request, const CreateAssessmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::CreateAssessment, request, handler, context); } /** *

Creates a custom framework in Audit Manager.

See Also:

AWS * API Reference

*/ virtual Model::CreateAssessmentFrameworkOutcome CreateAssessmentFramework(const Model::CreateAssessmentFrameworkRequest& request) const; /** * A Callable wrapper for CreateAssessmentFramework that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAssessmentFrameworkOutcomeCallable CreateAssessmentFrameworkCallable(const CreateAssessmentFrameworkRequestT& request) const { return SubmitCallable(&AuditManagerClient::CreateAssessmentFramework, request); } /** * An Async wrapper for CreateAssessmentFramework that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAssessmentFrameworkAsync(const CreateAssessmentFrameworkRequestT& request, const CreateAssessmentFrameworkResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::CreateAssessmentFramework, request, handler, context); } /** *

Creates an assessment report for the specified assessment.

See * Also:

AWS * API Reference

*/ virtual Model::CreateAssessmentReportOutcome CreateAssessmentReport(const Model::CreateAssessmentReportRequest& request) const; /** * A Callable wrapper for CreateAssessmentReport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAssessmentReportOutcomeCallable CreateAssessmentReportCallable(const CreateAssessmentReportRequestT& request) const { return SubmitCallable(&AuditManagerClient::CreateAssessmentReport, request); } /** * An Async wrapper for CreateAssessmentReport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAssessmentReportAsync(const CreateAssessmentReportRequestT& request, const CreateAssessmentReportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::CreateAssessmentReport, request, handler, context); } /** *

Creates a new custom control in Audit Manager.

See Also:

* AWS * API Reference

*/ virtual Model::CreateControlOutcome CreateControl(const Model::CreateControlRequest& request) const; /** * A Callable wrapper for CreateControl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateControlOutcomeCallable CreateControlCallable(const CreateControlRequestT& request) const { return SubmitCallable(&AuditManagerClient::CreateControl, request); } /** * An Async wrapper for CreateControl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateControlAsync(const CreateControlRequestT& request, const CreateControlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::CreateControl, request, handler, context); } /** *

Deletes an assessment in Audit Manager.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAssessmentOutcome DeleteAssessment(const Model::DeleteAssessmentRequest& request) const; /** * A Callable wrapper for DeleteAssessment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAssessmentOutcomeCallable DeleteAssessmentCallable(const DeleteAssessmentRequestT& request) const { return SubmitCallable(&AuditManagerClient::DeleteAssessment, request); } /** * An Async wrapper for DeleteAssessment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAssessmentAsync(const DeleteAssessmentRequestT& request, const DeleteAssessmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::DeleteAssessment, request, handler, context); } /** *

Deletes a custom framework in Audit Manager.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAssessmentFrameworkOutcome DeleteAssessmentFramework(const Model::DeleteAssessmentFrameworkRequest& request) const; /** * A Callable wrapper for DeleteAssessmentFramework that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAssessmentFrameworkOutcomeCallable DeleteAssessmentFrameworkCallable(const DeleteAssessmentFrameworkRequestT& request) const { return SubmitCallable(&AuditManagerClient::DeleteAssessmentFramework, request); } /** * An Async wrapper for DeleteAssessmentFramework that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAssessmentFrameworkAsync(const DeleteAssessmentFrameworkRequestT& request, const DeleteAssessmentFrameworkResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::DeleteAssessmentFramework, request, handler, context); } /** *

Deletes a share request for a custom framework in Audit Manager. *

See Also:

AWS * API Reference

*/ virtual Model::DeleteAssessmentFrameworkShareOutcome DeleteAssessmentFrameworkShare(const Model::DeleteAssessmentFrameworkShareRequest& request) const; /** * A Callable wrapper for DeleteAssessmentFrameworkShare that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAssessmentFrameworkShareOutcomeCallable DeleteAssessmentFrameworkShareCallable(const DeleteAssessmentFrameworkShareRequestT& request) const { return SubmitCallable(&AuditManagerClient::DeleteAssessmentFrameworkShare, request); } /** * An Async wrapper for DeleteAssessmentFrameworkShare that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAssessmentFrameworkShareAsync(const DeleteAssessmentFrameworkShareRequestT& request, const DeleteAssessmentFrameworkShareResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::DeleteAssessmentFrameworkShare, request, handler, context); } /** *

Deletes an assessment report in Audit Manager.

When you run the * DeleteAssessmentReport operation, Audit Manager attempts to delete * the following data:

  1. The specified assessment report that’s * stored in your S3 bucket

  2. The associated metadata that’s stored * in Audit Manager

If Audit Manager can’t access the assessment * report in your S3 bucket, the report isn’t deleted. In this event, the * DeleteAssessmentReport operation doesn’t fail. Instead, it proceeds * to delete the associated metadata only. You must then delete the assessment * report from the S3 bucket yourself.

This scenario happens when Audit * Manager receives a 403 (Forbidden) or 404 (Not Found) * error from Amazon S3. To avoid this, make sure that your S3 bucket is available, * and that you configured the correct permissions for Audit Manager to delete * resources in your S3 bucket. For an example permissions policy that you can use, * see Assessment * report destination permissions in the Audit Manager User Guide. For * information about the issues that could cause a 403 (Forbidden) or * 404 (Not Found) error from Amazon S3, see List * of Error Codes in the Amazon Simple Storage Service API Reference. *

See Also:

AWS * API Reference

*/ virtual Model::DeleteAssessmentReportOutcome DeleteAssessmentReport(const Model::DeleteAssessmentReportRequest& request) const; /** * A Callable wrapper for DeleteAssessmentReport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAssessmentReportOutcomeCallable DeleteAssessmentReportCallable(const DeleteAssessmentReportRequestT& request) const { return SubmitCallable(&AuditManagerClient::DeleteAssessmentReport, request); } /** * An Async wrapper for DeleteAssessmentReport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAssessmentReportAsync(const DeleteAssessmentReportRequestT& request, const DeleteAssessmentReportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::DeleteAssessmentReport, request, handler, context); } /** *

Deletes a custom control in Audit Manager.

When you * invoke this operation, the custom control is deleted from any frameworks or * assessments that it’s currently part of. As a result, Audit Manager will stop * collecting evidence for that custom control in all of your assessments. This * includes assessments that you previously created before you deleted the custom * control.

See Also:

AWS * API Reference

*/ virtual Model::DeleteControlOutcome DeleteControl(const Model::DeleteControlRequest& request) const; /** * A Callable wrapper for DeleteControl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteControlOutcomeCallable DeleteControlCallable(const DeleteControlRequestT& request) const { return SubmitCallable(&AuditManagerClient::DeleteControl, request); } /** * An Async wrapper for DeleteControl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteControlAsync(const DeleteControlRequestT& request, const DeleteControlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::DeleteControl, request, handler, context); } /** *

Deregisters an account in Audit Manager.

Before you * deregister, you can use the UpdateSettings * API operation to set your preferred data retention policy. By default, Audit * Manager retains your data. If you want to delete your data, you can use the * DeregistrationPolicy attribute to request the deletion of your * data.

For more information about data retention, see Data * Protection in the Audit Manager User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::DeregisterAccountOutcome DeregisterAccount(const Model::DeregisterAccountRequest& request) const; /** * A Callable wrapper for DeregisterAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterAccountOutcomeCallable DeregisterAccountCallable(const DeregisterAccountRequestT& request) const { return SubmitCallable(&AuditManagerClient::DeregisterAccount, request); } /** * An Async wrapper for DeregisterAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterAccountAsync(const DeregisterAccountRequestT& request, const DeregisterAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::DeregisterAccount, request, handler, context); } /** *

Removes the specified Amazon Web Services account as a delegated * administrator for Audit Manager.

When you remove a delegated * administrator from your Audit Manager settings, you continue to have access to * the evidence that you previously collected under that account. This is also the * case when you deregister a delegated administrator from Organizations. However, * Audit Manager stops collecting and attaching evidence to that delegated * administrator account moving forward.

Keep in mind the * following cleanup task if you use evidence finder:

Before you use your * management account to remove a delegated administrator, make sure that the * current delegated administrator account signs in to Audit Manager and disables * evidence finder first. Disabling evidence finder automatically deletes the event * data store that was created in their account when they enabled evidence finder. * If this task isn’t completed, the event data store remains in their account. In * this case, we recommend that the original delegated administrator goes to * CloudTrail Lake and manually deletes * the event data store.

This cleanup task is necessary to ensure that * you don't end up with multiple event data stores. Audit Manager ignores an * unused event data store after you remove or change a delegated administrator * account. However, the unused event data store continues to incur storage costs * from CloudTrail Lake if you don't delete it.

When you * deregister a delegated administrator account for Audit Manager, the data for * that account isn’t deleted. If you want to delete resource data for a delegated * administrator account, you must perform that task separately before you * deregister the account. Either, you can do this in the Audit Manager console. * Or, you can use one of the delete API operations that are provided by Audit * Manager.

To delete your Audit Manager resource data, see the following * instructions:

*

At this time, Audit Manager doesn't provide an option to delete evidence for * a specific delegated administrator. Instead, when your management account * deregisters Audit Manager, we perform a cleanup for the current delegated * administrator account at the time of deregistration.

See Also:

* AWS * API Reference

*/ virtual Model::DeregisterOrganizationAdminAccountOutcome DeregisterOrganizationAdminAccount(const Model::DeregisterOrganizationAdminAccountRequest& request) const; /** * A Callable wrapper for DeregisterOrganizationAdminAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterOrganizationAdminAccountOutcomeCallable DeregisterOrganizationAdminAccountCallable(const DeregisterOrganizationAdminAccountRequestT& request) const { return SubmitCallable(&AuditManagerClient::DeregisterOrganizationAdminAccount, request); } /** * An Async wrapper for DeregisterOrganizationAdminAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterOrganizationAdminAccountAsync(const DeregisterOrganizationAdminAccountRequestT& request, const DeregisterOrganizationAdminAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::DeregisterOrganizationAdminAccount, request, handler, context); } /** *

Disassociates an evidence folder from the specified assessment report in * Audit Manager.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateAssessmentReportEvidenceFolderOutcome DisassociateAssessmentReportEvidenceFolder(const Model::DisassociateAssessmentReportEvidenceFolderRequest& request) const; /** * A Callable wrapper for DisassociateAssessmentReportEvidenceFolder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateAssessmentReportEvidenceFolderOutcomeCallable DisassociateAssessmentReportEvidenceFolderCallable(const DisassociateAssessmentReportEvidenceFolderRequestT& request) const { return SubmitCallable(&AuditManagerClient::DisassociateAssessmentReportEvidenceFolder, request); } /** * An Async wrapper for DisassociateAssessmentReportEvidenceFolder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateAssessmentReportEvidenceFolderAsync(const DisassociateAssessmentReportEvidenceFolderRequestT& request, const DisassociateAssessmentReportEvidenceFolderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::DisassociateAssessmentReportEvidenceFolder, request, handler, context); } /** *

Gets the registration status of an account in Audit Manager.

See * Also:

AWS * API Reference

*/ virtual Model::GetAccountStatusOutcome GetAccountStatus(const Model::GetAccountStatusRequest& request) const; /** * A Callable wrapper for GetAccountStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAccountStatusOutcomeCallable GetAccountStatusCallable(const GetAccountStatusRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetAccountStatus, request); } /** * An Async wrapper for GetAccountStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAccountStatusAsync(const GetAccountStatusRequestT& request, const GetAccountStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetAccountStatus, request, handler, context); } /** *

Gets information about a specified assessment.

See Also:

AWS * API Reference

*/ virtual Model::GetAssessmentOutcome GetAssessment(const Model::GetAssessmentRequest& request) const; /** * A Callable wrapper for GetAssessment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAssessmentOutcomeCallable GetAssessmentCallable(const GetAssessmentRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetAssessment, request); } /** * An Async wrapper for GetAssessment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAssessmentAsync(const GetAssessmentRequestT& request, const GetAssessmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetAssessment, request, handler, context); } /** *

Gets information about a specified framework.

See Also:

AWS * API Reference

*/ virtual Model::GetAssessmentFrameworkOutcome GetAssessmentFramework(const Model::GetAssessmentFrameworkRequest& request) const; /** * A Callable wrapper for GetAssessmentFramework that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAssessmentFrameworkOutcomeCallable GetAssessmentFrameworkCallable(const GetAssessmentFrameworkRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetAssessmentFramework, request); } /** * An Async wrapper for GetAssessmentFramework that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAssessmentFrameworkAsync(const GetAssessmentFrameworkRequestT& request, const GetAssessmentFrameworkResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetAssessmentFramework, request, handler, context); } /** *

Gets the URL of an assessment report in Audit Manager.

See * Also:

AWS * API Reference

*/ virtual Model::GetAssessmentReportUrlOutcome GetAssessmentReportUrl(const Model::GetAssessmentReportUrlRequest& request) const; /** * A Callable wrapper for GetAssessmentReportUrl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAssessmentReportUrlOutcomeCallable GetAssessmentReportUrlCallable(const GetAssessmentReportUrlRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetAssessmentReportUrl, request); } /** * An Async wrapper for GetAssessmentReportUrl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAssessmentReportUrlAsync(const GetAssessmentReportUrlRequestT& request, const GetAssessmentReportUrlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetAssessmentReportUrl, request, handler, context); } /** *

Gets a list of changelogs from Audit Manager.

See Also:

AWS * API Reference

*/ virtual Model::GetChangeLogsOutcome GetChangeLogs(const Model::GetChangeLogsRequest& request) const; /** * A Callable wrapper for GetChangeLogs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetChangeLogsOutcomeCallable GetChangeLogsCallable(const GetChangeLogsRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetChangeLogs, request); } /** * An Async wrapper for GetChangeLogs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetChangeLogsAsync(const GetChangeLogsRequestT& request, const GetChangeLogsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetChangeLogs, request, handler, context); } /** *

Gets information about a specified control.

See Also:

AWS * API Reference

*/ virtual Model::GetControlOutcome GetControl(const Model::GetControlRequest& request) const; /** * A Callable wrapper for GetControl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetControlOutcomeCallable GetControlCallable(const GetControlRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetControl, request); } /** * An Async wrapper for GetControl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetControlAsync(const GetControlRequestT& request, const GetControlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetControl, request, handler, context); } /** *

Gets a list of delegations from an audit owner to a delegate.

See * Also:

AWS * API Reference

*/ virtual Model::GetDelegationsOutcome GetDelegations(const Model::GetDelegationsRequest& request) const; /** * A Callable wrapper for GetDelegations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDelegationsOutcomeCallable GetDelegationsCallable(const GetDelegationsRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetDelegations, request); } /** * An Async wrapper for GetDelegations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDelegationsAsync(const GetDelegationsRequestT& request, const GetDelegationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetDelegations, request, handler, context); } /** *

Gets information about a specified evidence item.

See Also:

* AWS * API Reference

*/ virtual Model::GetEvidenceOutcome GetEvidence(const Model::GetEvidenceRequest& request) const; /** * A Callable wrapper for GetEvidence that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEvidenceOutcomeCallable GetEvidenceCallable(const GetEvidenceRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetEvidence, request); } /** * An Async wrapper for GetEvidence that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEvidenceAsync(const GetEvidenceRequestT& request, const GetEvidenceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetEvidence, request, handler, context); } /** *

Gets all evidence from a specified evidence folder in Audit Manager. *

See Also:

AWS * API Reference

*/ virtual Model::GetEvidenceByEvidenceFolderOutcome GetEvidenceByEvidenceFolder(const Model::GetEvidenceByEvidenceFolderRequest& request) const; /** * A Callable wrapper for GetEvidenceByEvidenceFolder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEvidenceByEvidenceFolderOutcomeCallable GetEvidenceByEvidenceFolderCallable(const GetEvidenceByEvidenceFolderRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetEvidenceByEvidenceFolder, request); } /** * An Async wrapper for GetEvidenceByEvidenceFolder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEvidenceByEvidenceFolderAsync(const GetEvidenceByEvidenceFolderRequestT& request, const GetEvidenceByEvidenceFolderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetEvidenceByEvidenceFolder, request, handler, context); } /** *

Creates a presigned Amazon S3 URL that can be used to upload a file as manual * evidence. For instructions on how to use this operation, see Upload * a file from your browser in the Audit Manager User Guide.

The * following restrictions apply to this operation:

  • Maximum size of * an individual evidence file: 100 MB

  • Number of daily manual * evidence uploads per control: 100

  • Supported file formats: See * Supported * file types for manual evidence in the Audit Manager User Guide

    *

For more information about Audit Manager service restrictions, * see Quotas * and restrictions for Audit Manager.

See Also:

AWS * API Reference

*/ virtual Model::GetEvidenceFileUploadUrlOutcome GetEvidenceFileUploadUrl(const Model::GetEvidenceFileUploadUrlRequest& request) const; /** * A Callable wrapper for GetEvidenceFileUploadUrl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEvidenceFileUploadUrlOutcomeCallable GetEvidenceFileUploadUrlCallable(const GetEvidenceFileUploadUrlRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetEvidenceFileUploadUrl, request); } /** * An Async wrapper for GetEvidenceFileUploadUrl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEvidenceFileUploadUrlAsync(const GetEvidenceFileUploadUrlRequestT& request, const GetEvidenceFileUploadUrlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetEvidenceFileUploadUrl, request, handler, context); } /** *

Gets an evidence folder from a specified assessment in Audit Manager. *

See Also:

AWS * API Reference

*/ virtual Model::GetEvidenceFolderOutcome GetEvidenceFolder(const Model::GetEvidenceFolderRequest& request) const; /** * A Callable wrapper for GetEvidenceFolder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEvidenceFolderOutcomeCallable GetEvidenceFolderCallable(const GetEvidenceFolderRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetEvidenceFolder, request); } /** * An Async wrapper for GetEvidenceFolder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEvidenceFolderAsync(const GetEvidenceFolderRequestT& request, const GetEvidenceFolderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetEvidenceFolder, request, handler, context); } /** *

Gets the evidence folders from a specified assessment in Audit Manager. *

See Also:

AWS * API Reference

*/ virtual Model::GetEvidenceFoldersByAssessmentOutcome GetEvidenceFoldersByAssessment(const Model::GetEvidenceFoldersByAssessmentRequest& request) const; /** * A Callable wrapper for GetEvidenceFoldersByAssessment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEvidenceFoldersByAssessmentOutcomeCallable GetEvidenceFoldersByAssessmentCallable(const GetEvidenceFoldersByAssessmentRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetEvidenceFoldersByAssessment, request); } /** * An Async wrapper for GetEvidenceFoldersByAssessment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEvidenceFoldersByAssessmentAsync(const GetEvidenceFoldersByAssessmentRequestT& request, const GetEvidenceFoldersByAssessmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetEvidenceFoldersByAssessment, request, handler, context); } /** *

Gets a list of evidence folders that are associated with a specified control * in an Audit Manager assessment.

See Also:

AWS * API Reference

*/ virtual Model::GetEvidenceFoldersByAssessmentControlOutcome GetEvidenceFoldersByAssessmentControl(const Model::GetEvidenceFoldersByAssessmentControlRequest& request) const; /** * A Callable wrapper for GetEvidenceFoldersByAssessmentControl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEvidenceFoldersByAssessmentControlOutcomeCallable GetEvidenceFoldersByAssessmentControlCallable(const GetEvidenceFoldersByAssessmentControlRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetEvidenceFoldersByAssessmentControl, request); } /** * An Async wrapper for GetEvidenceFoldersByAssessmentControl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEvidenceFoldersByAssessmentControlAsync(const GetEvidenceFoldersByAssessmentControlRequestT& request, const GetEvidenceFoldersByAssessmentControlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetEvidenceFoldersByAssessmentControl, request, handler, context); } /** *

Gets the latest analytics data for all your current active assessments. *

See Also:

AWS * API Reference

*/ virtual Model::GetInsightsOutcome GetInsights(const Model::GetInsightsRequest& request) const; /** * A Callable wrapper for GetInsights that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInsightsOutcomeCallable GetInsightsCallable(const GetInsightsRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetInsights, request); } /** * An Async wrapper for GetInsights that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInsightsAsync(const GetInsightsRequestT& request, const GetInsightsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetInsights, request, handler, context); } /** *

Gets the latest analytics data for a specific active assessment. *

See Also:

AWS * API Reference

*/ virtual Model::GetInsightsByAssessmentOutcome GetInsightsByAssessment(const Model::GetInsightsByAssessmentRequest& request) const; /** * A Callable wrapper for GetInsightsByAssessment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInsightsByAssessmentOutcomeCallable GetInsightsByAssessmentCallable(const GetInsightsByAssessmentRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetInsightsByAssessment, request); } /** * An Async wrapper for GetInsightsByAssessment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInsightsByAssessmentAsync(const GetInsightsByAssessmentRequestT& request, const GetInsightsByAssessmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetInsightsByAssessment, request, handler, context); } /** *

Gets the name of the delegated Amazon Web Services administrator account for * a specified organization.

See Also:

AWS * API Reference

*/ virtual Model::GetOrganizationAdminAccountOutcome GetOrganizationAdminAccount(const Model::GetOrganizationAdminAccountRequest& request) const; /** * A Callable wrapper for GetOrganizationAdminAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOrganizationAdminAccountOutcomeCallable GetOrganizationAdminAccountCallable(const GetOrganizationAdminAccountRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetOrganizationAdminAccount, request); } /** * An Async wrapper for GetOrganizationAdminAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOrganizationAdminAccountAsync(const GetOrganizationAdminAccountRequestT& request, const GetOrganizationAdminAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetOrganizationAdminAccount, request, handler, context); } /** *

Gets a list of all of the Amazon Web Services that you can choose to include * in your assessment. When you create * an assessment, specify which of these services you want to include to narrow * the assessment's scope.

See * Also:

AWS * API Reference

*/ virtual Model::GetServicesInScopeOutcome GetServicesInScope(const Model::GetServicesInScopeRequest& request) const; /** * A Callable wrapper for GetServicesInScope that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetServicesInScopeOutcomeCallable GetServicesInScopeCallable(const GetServicesInScopeRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetServicesInScope, request); } /** * An Async wrapper for GetServicesInScope that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetServicesInScopeAsync(const GetServicesInScopeRequestT& request, const GetServicesInScopeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetServicesInScope, request, handler, context); } /** *

Gets the settings for a specified Amazon Web Services account. *

See Also:

AWS * API Reference

*/ virtual Model::GetSettingsOutcome GetSettings(const Model::GetSettingsRequest& request) const; /** * A Callable wrapper for GetSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSettingsOutcomeCallable GetSettingsCallable(const GetSettingsRequestT& request) const { return SubmitCallable(&AuditManagerClient::GetSettings, request); } /** * An Async wrapper for GetSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSettingsAsync(const GetSettingsRequestT& request, const GetSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::GetSettings, request, handler, context); } /** *

Lists the latest analytics data for controls within a specific control domain * and a specific active assessment.

Control insights are listed only * if the control belongs to the control domain and assessment that was specified. * Moreover, the control must have collected evidence on the * lastUpdated date of controlInsightsByAssessment. If * neither of these conditions are met, no data is listed for that control.

*

See Also:

AWS * API Reference

*/ virtual Model::ListAssessmentControlInsightsByControlDomainOutcome ListAssessmentControlInsightsByControlDomain(const Model::ListAssessmentControlInsightsByControlDomainRequest& request) const; /** * A Callable wrapper for ListAssessmentControlInsightsByControlDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssessmentControlInsightsByControlDomainOutcomeCallable ListAssessmentControlInsightsByControlDomainCallable(const ListAssessmentControlInsightsByControlDomainRequestT& request) const { return SubmitCallable(&AuditManagerClient::ListAssessmentControlInsightsByControlDomain, request); } /** * An Async wrapper for ListAssessmentControlInsightsByControlDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssessmentControlInsightsByControlDomainAsync(const ListAssessmentControlInsightsByControlDomainRequestT& request, const ListAssessmentControlInsightsByControlDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::ListAssessmentControlInsightsByControlDomain, request, handler, context); } /** *

Returns a list of sent or received share requests for custom frameworks in * Audit Manager.

See Also:

AWS * API Reference

*/ virtual Model::ListAssessmentFrameworkShareRequestsOutcome ListAssessmentFrameworkShareRequests(const Model::ListAssessmentFrameworkShareRequestsRequest& request) const; /** * A Callable wrapper for ListAssessmentFrameworkShareRequests that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssessmentFrameworkShareRequestsOutcomeCallable ListAssessmentFrameworkShareRequestsCallable(const ListAssessmentFrameworkShareRequestsRequestT& request) const { return SubmitCallable(&AuditManagerClient::ListAssessmentFrameworkShareRequests, request); } /** * An Async wrapper for ListAssessmentFrameworkShareRequests that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssessmentFrameworkShareRequestsAsync(const ListAssessmentFrameworkShareRequestsRequestT& request, const ListAssessmentFrameworkShareRequestsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::ListAssessmentFrameworkShareRequests, request, handler, context); } /** *

Returns a list of the frameworks that are available in the Audit Manager * framework library.

See Also:

AWS * API Reference

*/ virtual Model::ListAssessmentFrameworksOutcome ListAssessmentFrameworks(const Model::ListAssessmentFrameworksRequest& request) const; /** * A Callable wrapper for ListAssessmentFrameworks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssessmentFrameworksOutcomeCallable ListAssessmentFrameworksCallable(const ListAssessmentFrameworksRequestT& request) const { return SubmitCallable(&AuditManagerClient::ListAssessmentFrameworks, request); } /** * An Async wrapper for ListAssessmentFrameworks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssessmentFrameworksAsync(const ListAssessmentFrameworksRequestT& request, const ListAssessmentFrameworksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::ListAssessmentFrameworks, request, handler, context); } /** *

Returns a list of assessment reports created in Audit Manager. *

See Also:

AWS * API Reference

*/ virtual Model::ListAssessmentReportsOutcome ListAssessmentReports(const Model::ListAssessmentReportsRequest& request) const; /** * A Callable wrapper for ListAssessmentReports that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssessmentReportsOutcomeCallable ListAssessmentReportsCallable(const ListAssessmentReportsRequestT& request) const { return SubmitCallable(&AuditManagerClient::ListAssessmentReports, request); } /** * An Async wrapper for ListAssessmentReports that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssessmentReportsAsync(const ListAssessmentReportsRequestT& request, const ListAssessmentReportsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::ListAssessmentReports, request, handler, context); } /** *

Returns a list of current and past assessments from Audit Manager. *

See Also:

AWS * API Reference

*/ virtual Model::ListAssessmentsOutcome ListAssessments(const Model::ListAssessmentsRequest& request) const; /** * A Callable wrapper for ListAssessments that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssessmentsOutcomeCallable ListAssessmentsCallable(const ListAssessmentsRequestT& request) const { return SubmitCallable(&AuditManagerClient::ListAssessments, request); } /** * An Async wrapper for ListAssessments that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssessmentsAsync(const ListAssessmentsRequestT& request, const ListAssessmentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::ListAssessments, request, handler, context); } /** *

Lists the latest analytics data for control domains across all of your active * assessments.

A control domain is listed only if at least one of * the controls within that domain collected evidence on the * lastUpdated date of controlDomainInsights. If this * condition isn’t met, no data is listed for that control domain.

*

See Also:

AWS * API Reference

*/ virtual Model::ListControlDomainInsightsOutcome ListControlDomainInsights(const Model::ListControlDomainInsightsRequest& request) const; /** * A Callable wrapper for ListControlDomainInsights that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListControlDomainInsightsOutcomeCallable ListControlDomainInsightsCallable(const ListControlDomainInsightsRequestT& request) const { return SubmitCallable(&AuditManagerClient::ListControlDomainInsights, request); } /** * An Async wrapper for ListControlDomainInsights that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListControlDomainInsightsAsync(const ListControlDomainInsightsRequestT& request, const ListControlDomainInsightsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::ListControlDomainInsights, request, handler, context); } /** *

Lists analytics data for control domains within a specified active * assessment.

A control domain is listed only if at least one of the * controls within that domain collected evidence on the lastUpdated * date of controlDomainInsights. If this condition isn’t met, no data * is listed for that domain.

See Also:

AWS * API Reference

*/ virtual Model::ListControlDomainInsightsByAssessmentOutcome ListControlDomainInsightsByAssessment(const Model::ListControlDomainInsightsByAssessmentRequest& request) const; /** * A Callable wrapper for ListControlDomainInsightsByAssessment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListControlDomainInsightsByAssessmentOutcomeCallable ListControlDomainInsightsByAssessmentCallable(const ListControlDomainInsightsByAssessmentRequestT& request) const { return SubmitCallable(&AuditManagerClient::ListControlDomainInsightsByAssessment, request); } /** * An Async wrapper for ListControlDomainInsightsByAssessment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListControlDomainInsightsByAssessmentAsync(const ListControlDomainInsightsByAssessmentRequestT& request, const ListControlDomainInsightsByAssessmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::ListControlDomainInsightsByAssessment, request, handler, context); } /** *

Lists the latest analytics data for controls within a specific control domain * across all active assessments.

Control insights are listed only if * the control belongs to the control domain that was specified and the control * collected evidence on the lastUpdated date of * controlInsightsMetadata. If neither of these conditions are met, no * data is listed for that control.

See Also:

AWS * API Reference

*/ virtual Model::ListControlInsightsByControlDomainOutcome ListControlInsightsByControlDomain(const Model::ListControlInsightsByControlDomainRequest& request) const; /** * A Callable wrapper for ListControlInsightsByControlDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListControlInsightsByControlDomainOutcomeCallable ListControlInsightsByControlDomainCallable(const ListControlInsightsByControlDomainRequestT& request) const { return SubmitCallable(&AuditManagerClient::ListControlInsightsByControlDomain, request); } /** * An Async wrapper for ListControlInsightsByControlDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListControlInsightsByControlDomainAsync(const ListControlInsightsByControlDomainRequestT& request, const ListControlInsightsByControlDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::ListControlInsightsByControlDomain, request, handler, context); } /** *

Returns a list of controls from Audit Manager.

See Also:

* AWS * API Reference

*/ virtual Model::ListControlsOutcome ListControls(const Model::ListControlsRequest& request) const; /** * A Callable wrapper for ListControls that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListControlsOutcomeCallable ListControlsCallable(const ListControlsRequestT& request) const { return SubmitCallable(&AuditManagerClient::ListControls, request); } /** * An Async wrapper for ListControls that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListControlsAsync(const ListControlsRequestT& request, const ListControlsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::ListControls, request, handler, context); } /** *

Returns a list of keywords that are pre-mapped to the specified control data * source.

See Also:

AWS * API Reference

*/ virtual Model::ListKeywordsForDataSourceOutcome ListKeywordsForDataSource(const Model::ListKeywordsForDataSourceRequest& request) const; /** * A Callable wrapper for ListKeywordsForDataSource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListKeywordsForDataSourceOutcomeCallable ListKeywordsForDataSourceCallable(const ListKeywordsForDataSourceRequestT& request) const { return SubmitCallable(&AuditManagerClient::ListKeywordsForDataSource, request); } /** * An Async wrapper for ListKeywordsForDataSource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListKeywordsForDataSourceAsync(const ListKeywordsForDataSourceRequestT& request, const ListKeywordsForDataSourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::ListKeywordsForDataSource, request, handler, context); } /** *

Returns a list of all Audit Manager notifications.

See Also:

* AWS * API Reference

*/ virtual Model::ListNotificationsOutcome ListNotifications(const Model::ListNotificationsRequest& request) const; /** * A Callable wrapper for ListNotifications that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListNotificationsOutcomeCallable ListNotificationsCallable(const ListNotificationsRequestT& request) const { return SubmitCallable(&AuditManagerClient::ListNotifications, request); } /** * An Async wrapper for ListNotifications that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListNotificationsAsync(const ListNotificationsRequestT& request, const ListNotificationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::ListNotifications, request, handler, context); } /** *

Returns a list of tags for the specified resource in Audit Manager. *

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&AuditManagerClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::ListTagsForResource, request, handler, context); } /** *

Enables Audit Manager for the specified Amazon Web Services account. *

See Also:

AWS * API Reference

*/ virtual Model::RegisterAccountOutcome RegisterAccount(const Model::RegisterAccountRequest& request) const; /** * A Callable wrapper for RegisterAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterAccountOutcomeCallable RegisterAccountCallable(const RegisterAccountRequestT& request) const { return SubmitCallable(&AuditManagerClient::RegisterAccount, request); } /** * An Async wrapper for RegisterAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterAccountAsync(const RegisterAccountRequestT& request, const RegisterAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::RegisterAccount, request, handler, context); } /** *

Enables an Amazon Web Services account within the organization as the * delegated administrator for Audit Manager.

See Also:

AWS * API Reference

*/ virtual Model::RegisterOrganizationAdminAccountOutcome RegisterOrganizationAdminAccount(const Model::RegisterOrganizationAdminAccountRequest& request) const; /** * A Callable wrapper for RegisterOrganizationAdminAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterOrganizationAdminAccountOutcomeCallable RegisterOrganizationAdminAccountCallable(const RegisterOrganizationAdminAccountRequestT& request) const { return SubmitCallable(&AuditManagerClient::RegisterOrganizationAdminAccount, request); } /** * An Async wrapper for RegisterOrganizationAdminAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterOrganizationAdminAccountAsync(const RegisterOrganizationAdminAccountRequestT& request, const RegisterOrganizationAdminAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::RegisterOrganizationAdminAccount, request, handler, context); } /** *

Creates a share request for a custom framework in Audit Manager.

The * share request specifies a recipient and notifies them that a custom framework is * available. Recipients have 120 days to accept or decline the request. If no * action is taken, the share request expires.

When you create a share * request, Audit Manager stores a snapshot of your custom framework in the US East * (N. Virginia) Amazon Web Services Region. Audit Manager also stores a backup of * the same snapshot in the US West (Oregon) Amazon Web Services Region.

*

Audit Manager deletes the snapshot and the backup snapshot when one of the * following events occurs:

  • The sender revokes the share * request.

  • The recipient declines the share request.

    • *

  • The recipient encounters an error and doesn't successfully accept the * share request.

  • The share request expires before the recipient * responds to the request.

When a sender resends * a share request, the snapshot is replaced with an updated version that * corresponds with the latest version of the custom framework.

When a * recipient accepts a share request, the snapshot is replicated into their Amazon * Web Services account under the Amazon Web Services Region that was specified in * the share request.

When you invoke the * StartAssessmentFrameworkShare API, you are about to share a custom * framework with another Amazon Web Services account. You may not share a custom * framework that is derived from a standard framework if the standard framework is * designated as not eligible for sharing by Amazon Web Services, unless you have * obtained permission to do so from the owner of the standard framework. To learn * more about which standard frameworks are eligible for sharing, see Framework * sharing eligibility in the Audit Manager User Guide.

*

See Also:

AWS * API Reference

*/ virtual Model::StartAssessmentFrameworkShareOutcome StartAssessmentFrameworkShare(const Model::StartAssessmentFrameworkShareRequest& request) const; /** * A Callable wrapper for StartAssessmentFrameworkShare that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartAssessmentFrameworkShareOutcomeCallable StartAssessmentFrameworkShareCallable(const StartAssessmentFrameworkShareRequestT& request) const { return SubmitCallable(&AuditManagerClient::StartAssessmentFrameworkShare, request); } /** * An Async wrapper for StartAssessmentFrameworkShare that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartAssessmentFrameworkShareAsync(const StartAssessmentFrameworkShareRequestT& request, const StartAssessmentFrameworkShareResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::StartAssessmentFrameworkShare, request, handler, context); } /** *

Tags the specified resource in Audit Manager.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&AuditManagerClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::TagResource, request, handler, context); } /** *

Removes a tag from a resource in Audit Manager.

See Also:

* AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&AuditManagerClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::UntagResource, request, handler, context); } /** *

Edits an Audit Manager assessment.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAssessmentOutcome UpdateAssessment(const Model::UpdateAssessmentRequest& request) const; /** * A Callable wrapper for UpdateAssessment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAssessmentOutcomeCallable UpdateAssessmentCallable(const UpdateAssessmentRequestT& request) const { return SubmitCallable(&AuditManagerClient::UpdateAssessment, request); } /** * An Async wrapper for UpdateAssessment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAssessmentAsync(const UpdateAssessmentRequestT& request, const UpdateAssessmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::UpdateAssessment, request, handler, context); } /** *

Updates a control within an assessment in Audit Manager.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateAssessmentControlOutcome UpdateAssessmentControl(const Model::UpdateAssessmentControlRequest& request) const; /** * A Callable wrapper for UpdateAssessmentControl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAssessmentControlOutcomeCallable UpdateAssessmentControlCallable(const UpdateAssessmentControlRequestT& request) const { return SubmitCallable(&AuditManagerClient::UpdateAssessmentControl, request); } /** * An Async wrapper for UpdateAssessmentControl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAssessmentControlAsync(const UpdateAssessmentControlRequestT& request, const UpdateAssessmentControlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::UpdateAssessmentControl, request, handler, context); } /** *

Updates the status of a control set in an Audit Manager assessment. *

See Also:

AWS * API Reference

*/ virtual Model::UpdateAssessmentControlSetStatusOutcome UpdateAssessmentControlSetStatus(const Model::UpdateAssessmentControlSetStatusRequest& request) const; /** * A Callable wrapper for UpdateAssessmentControlSetStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAssessmentControlSetStatusOutcomeCallable UpdateAssessmentControlSetStatusCallable(const UpdateAssessmentControlSetStatusRequestT& request) const { return SubmitCallable(&AuditManagerClient::UpdateAssessmentControlSetStatus, request); } /** * An Async wrapper for UpdateAssessmentControlSetStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAssessmentControlSetStatusAsync(const UpdateAssessmentControlSetStatusRequestT& request, const UpdateAssessmentControlSetStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::UpdateAssessmentControlSetStatus, request, handler, context); } /** *

Updates a custom framework in Audit Manager.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAssessmentFrameworkOutcome UpdateAssessmentFramework(const Model::UpdateAssessmentFrameworkRequest& request) const; /** * A Callable wrapper for UpdateAssessmentFramework that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAssessmentFrameworkOutcomeCallable UpdateAssessmentFrameworkCallable(const UpdateAssessmentFrameworkRequestT& request) const { return SubmitCallable(&AuditManagerClient::UpdateAssessmentFramework, request); } /** * An Async wrapper for UpdateAssessmentFramework that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAssessmentFrameworkAsync(const UpdateAssessmentFrameworkRequestT& request, const UpdateAssessmentFrameworkResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::UpdateAssessmentFramework, request, handler, context); } /** *

Updates a share request for a custom framework in Audit Manager. *

See Also:

AWS * API Reference

*/ virtual Model::UpdateAssessmentFrameworkShareOutcome UpdateAssessmentFrameworkShare(const Model::UpdateAssessmentFrameworkShareRequest& request) const; /** * A Callable wrapper for UpdateAssessmentFrameworkShare that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAssessmentFrameworkShareOutcomeCallable UpdateAssessmentFrameworkShareCallable(const UpdateAssessmentFrameworkShareRequestT& request) const { return SubmitCallable(&AuditManagerClient::UpdateAssessmentFrameworkShare, request); } /** * An Async wrapper for UpdateAssessmentFrameworkShare that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAssessmentFrameworkShareAsync(const UpdateAssessmentFrameworkShareRequestT& request, const UpdateAssessmentFrameworkShareResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::UpdateAssessmentFrameworkShare, request, handler, context); } /** *

Updates the status of an assessment in Audit Manager.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateAssessmentStatusOutcome UpdateAssessmentStatus(const Model::UpdateAssessmentStatusRequest& request) const; /** * A Callable wrapper for UpdateAssessmentStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAssessmentStatusOutcomeCallable UpdateAssessmentStatusCallable(const UpdateAssessmentStatusRequestT& request) const { return SubmitCallable(&AuditManagerClient::UpdateAssessmentStatus, request); } /** * An Async wrapper for UpdateAssessmentStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAssessmentStatusAsync(const UpdateAssessmentStatusRequestT& request, const UpdateAssessmentStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::UpdateAssessmentStatus, request, handler, context); } /** *

Updates a custom control in Audit Manager.

See Also:

AWS * API Reference

*/ virtual Model::UpdateControlOutcome UpdateControl(const Model::UpdateControlRequest& request) const; /** * A Callable wrapper for UpdateControl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateControlOutcomeCallable UpdateControlCallable(const UpdateControlRequestT& request) const { return SubmitCallable(&AuditManagerClient::UpdateControl, request); } /** * An Async wrapper for UpdateControl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateControlAsync(const UpdateControlRequestT& request, const UpdateControlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::UpdateControl, request, handler, context); } /** *

Updates Audit Manager settings for the current account.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateSettingsOutcome UpdateSettings(const Model::UpdateSettingsRequest& request) const; /** * A Callable wrapper for UpdateSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateSettingsOutcomeCallable UpdateSettingsCallable(const UpdateSettingsRequestT& request) const { return SubmitCallable(&AuditManagerClient::UpdateSettings, request); } /** * An Async wrapper for UpdateSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateSettingsAsync(const UpdateSettingsRequestT& request, const UpdateSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::UpdateSettings, request, handler, context); } /** *

Validates the integrity of an assessment report in Audit Manager. *

See Also:

AWS * API Reference

*/ virtual Model::ValidateAssessmentReportIntegrityOutcome ValidateAssessmentReportIntegrity(const Model::ValidateAssessmentReportIntegrityRequest& request) const; /** * A Callable wrapper for ValidateAssessmentReportIntegrity that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ValidateAssessmentReportIntegrityOutcomeCallable ValidateAssessmentReportIntegrityCallable(const ValidateAssessmentReportIntegrityRequestT& request) const { return SubmitCallable(&AuditManagerClient::ValidateAssessmentReportIntegrity, request); } /** * An Async wrapper for ValidateAssessmentReportIntegrity that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ValidateAssessmentReportIntegrityAsync(const ValidateAssessmentReportIntegrityRequestT& request, const ValidateAssessmentReportIntegrityResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AuditManagerClient::ValidateAssessmentReportIntegrity, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const AuditManagerClientConfiguration& clientConfiguration); AuditManagerClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace AuditManager } // namespace Aws