Module aws_sdk_auditmanager::types

Data structures used by operation inputs/outputs.

Modules

• builders
  Builders
• error
  Error types that AWS Audit Manager can respond with.

Structs

• Assessment

  An entity that defines the scope of audit evidence collected by Audit Manager. An Audit Manager assessment is an implementation of an Audit Manager framework.

• AssessmentControl

  The control entity that represents a standard control or a custom control in an Audit Manager assessment.

• AssessmentControlSet

  Represents a set of controls in an Audit Manager assessment.

• AssessmentEvidenceFolder

  The folder where Audit Manager stores evidence for an assessment.

• AssessmentFramework

  The file used to structure and automate Audit Manager assessments for a given compliance standard.

• AssessmentFrameworkMetadata

  The metadata that's associated with a standard framework or a custom framework.

• AssessmentFrameworkShareRequest

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

• AssessmentMetadata

  The metadata that's associated with the specified assessment.

• AssessmentMetadataItem

  A metadata object that's associated with an assessment in Audit Manager.

• AssessmentReport

  A finalized document that's generated from an Audit Manager assessment. These reports summarize the relevant evidence that was collected for your audit, and link to the relevant evidence folders. These evidence folders are named and organized according to the controls that are specified in your assessment.

• AssessmentReportEvidenceError

  An error entity for assessment report evidence errors. This is used to provide more meaningful errors than a simple string message.

• AssessmentReportMetadata

  The metadata objects that are associated with the specified assessment report.

• AssessmentReportsDestination

  The location where Audit Manager saves assessment reports for the given assessment.

• AwsAccount

  The wrapper of Amazon Web Services account details, such as account ID or email address.

• AwsService

  An Amazon Web Service such as Amazon S3 or CloudTrail.

• BatchCreateDelegationByAssessmentError

  An error entity for the BatchCreateDelegationByAssessment API. This is used to provide more meaningful errors than a simple string message.

• BatchDeleteDelegationByAssessmentError

  An error entity for the BatchDeleteDelegationByAssessment API. This is used to provide more meaningful errors than a simple string message.

• BatchImportEvidenceToAssessmentControlError

  An error entity for the BatchImportEvidenceToAssessmentControl API. This is used to provide more meaningful errors than a simple string message.

• ChangeLog

  The record of a change within Audit Manager. For example, this could be the status change of an assessment or the delegation of a control set.

• Control

  A control in Audit Manager.

• ControlComment

  A comment that's posted by a user on a control. This includes the author's name, the comment text, and a timestamp.

• ControlDomainInsights

  A summary of the latest analytics data for a specific control domain.

• ControlInsightsMetadataByAssessmentItem

  A summary of the latest analytics data for a specific control in a specific active assessment.

• ControlInsightsMetadataItem

  A summary of the latest analytics data for a specific control.

• ControlMappingSource

  The data source that determines where Audit Manager collects evidence from for the control.

• ControlMetadata

  The metadata that's associated with the standard control or custom control.

• ControlSet

  A set of controls in Audit Manager.

• CreateAssessmentFrameworkControl

  The control entity attributes that uniquely identify an existing control to be added to a framework in Audit Manager.

• CreateAssessmentFrameworkControlSet

  A controlSet entity that represents a collection of controls in Audit Manager. This doesn't contain the control set ID.

• CreateControlMappingSource

  The control mapping fields that represent the source for evidence collection, along with related parameters and metadata. This doesn't contain mappingID.

• CreateDelegationRequest

  A collection of attributes that's used to create a delegation for an assessment in Audit Manager.

• DefaultExportDestination

  The default s3 bucket where Audit Manager saves the files that you export from evidence finder.

• Delegation

  The assignment of a control set to a delegate for review.

• DelegationMetadata

  The metadata that's associated with the delegation.

• DeregistrationPolicy

  The deregistration policy for the data that's stored in Audit Manager. You can use this attribute to determine how your data is handled when you deregister Audit Manager.

• Evidence

  A record that contains the information needed to demonstrate compliance with the requirements specified by a control. Examples of evidence include change activity invoked by a user, or a system configuration snapshot.

• EvidenceFinderEnablement

  The settings object that specifies whether evidence finder is enabled. This object also describes the related event data store, and the backfill status for populating the event data store with evidence data.

• EvidenceInsights

  A breakdown of the latest compliance check status for the evidence in your Audit Manager assessments.

• Framework

  The file that's used to structure and automate Audit Manager assessments for a given compliance standard.

• FrameworkMetadata

  The metadata of a framework, such as the name, ID, or description.

• Insights

  A summary of the latest analytics data for all your active assessments.

• InsightsByAssessment

  A summary of the latest analytics data for a specific active assessment.

• ManualEvidence

  Evidence that's manually added to a control in Audit Manager. manualEvidence can be one of the following: evidenceFileName, s3ResourcePath, or textResponse.

• Notification

  The notification that informs a user of an update in Audit Manager. For example, this includes the notification that's sent when a control set is delegated for review.

• Resource

  A system asset that's evaluated in an Audit Manager assessment.

• Role

  The wrapper that contains the Audit Manager role information of the current user. This includes the role type and IAM Amazon Resource Name (ARN).

• Scope

  The wrapper that contains the Amazon Web Services accounts and services that are in scope for the assessment.

• ServiceMetadata

  The metadata that's associated with the Amazon Web Service.

• Settings

  The settings object that holds all supported Audit Manager settings.

• SourceKeyword

  A keyword that relates to the control data source.

• UpdateAssessmentFrameworkControlSet

  A controlSet entity that represents a collection of controls in Audit Manager. This doesn't contain the control set ID.

• Url

  Short for uniform resource locator. A URL is used as a unique identifier to locate a resource on the internet.

• ValidationExceptionField

  Indicates that the request has invalid or missing parameters for the field.

Enums

• AccountStatus
  When writing a match expression against AccountStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ActionEnum
  When writing a match expression against ActionEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AssessmentReportDestinationType
  When writing a match expression against AssessmentReportDestinationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AssessmentReportStatus
  When writing a match expression against AssessmentReportStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AssessmentStatus
  When writing a match expression against AssessmentStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ControlResponse
  When writing a match expression against ControlResponse, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ControlSetStatus
  When writing a match expression against ControlSetStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ControlStatus
  When writing a match expression against ControlStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ControlType
  When writing a match expression against ControlType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DelegationStatus
  When writing a match expression against DelegationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DeleteResources
  When writing a match expression against DeleteResources, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• EvidenceFinderBackfillStatus
  When writing a match expression against EvidenceFinderBackfillStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• EvidenceFinderEnablementStatus
  When writing a match expression against EvidenceFinderEnablementStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ExportDestinationType
  When writing a match expression against ExportDestinationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• FrameworkType
  When writing a match expression against FrameworkType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• KeywordInputType
  When writing a match expression against KeywordInputType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ObjectTypeEnum
  When writing a match expression against ObjectTypeEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RoleType
  When writing a match expression against RoleType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SettingAttribute
  When writing a match expression against SettingAttribute, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ShareRequestAction
  When writing a match expression against ShareRequestAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ShareRequestStatus
  When writing a match expression against ShareRequestStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ShareRequestType
  When writing a match expression against ShareRequestType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SourceFrequency
  When writing a match expression against SourceFrequency, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SourceSetUpOption
  When writing a match expression against SourceSetUpOption, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SourceType
  When writing a match expression against SourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ValidationExceptionReason
  When writing a match expression against ValidationExceptionReason, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.