Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that Data Automation for Amazon Bedrock can respond with.

Structs

AudioExtractionCategory

Category of Audio Extraction

AudioOverrideConfiguration

Override Configuration of Audio

AudioStandardExtraction

Standard Extraction Configuration of Audio

AudioStandardGenerativeField

Standard Generative Field Configuration of Audio

AudioStandardOutputConfiguration

Standard Output Configuration of Audio

Blueprint

Contains the information of a Blueprint.

BlueprintFilter

Blueprint Filter

BlueprintItem

Blueprint Item

BlueprintSummary

Summary of a Blueprint

CustomOutputConfiguration

Custom output configuration

DataAutomationProject

Contains the information of a DataAutomationProject.

DataAutomationProjectFilter

Data Automation Project Filter

DataAutomationProjectSummary

Summary of a DataAutomationProject

DocumentBoundingBox

Bounding Box Configuration of Document Extraction

DocumentExtractionGranularity

Granularity of Document Extraction

DocumentOutputAdditionalFileFormat

Additional File Format of Document Output

DocumentOutputFormat

Output Format of Document

DocumentOutputTextFormat

Text Format of Document Output

DocumentOverrideConfiguration

Override Configuration of Document

DocumentStandardExtraction

Standard Extraction Configuration of Document

DocumentStandardGenerativeField

Standard Generative Field Configuration of Document

DocumentStandardOutputConfiguration

Standard Output Configuration of Document

EncryptionConfiguration

KMS Encryption Configuration

ImageBoundingBox

Bounding Box Configuration of Image Extraction

ImageExtractionCategory

Category of Image Extraction

ImageOverrideConfiguration

Override Configuration of Image

ImageStandardExtraction

Standard Extraction Configuration of Image

ImageStandardGenerativeField

Standard Generative Field Configuration of Image

ImageStandardOutputConfiguration

Standard Output Configuration of Image

ModalityProcessingConfiguration

Configuration to enable/disable processing of modality

ModalityRoutingConfiguration

Configuration for routing file type to desired modality

OverrideConfiguration

Override configuration

SplitterConfiguration

Configuration of Splitter

StandardOutputConfiguration

Standard output configuration

Tag

Key value pair of a tag

ValidationExceptionField

Stores information about a field passed inside a request that resulted in an exception

VideoBoundingBox

Bounding Box Configuration of Video Extraction

VideoExtractionCategory

Category of Video Extraction

VideoOverrideConfiguration

Override Configuration of Video

VideoStandardExtraction

Standard Extraction Configuration of Video

VideoStandardGenerativeField

Standard Generative Field Configuration of Video

VideoStandardOutputConfiguration

Standard Output Configuration of Video

Enums

AudioExtractionCategoryType

When writing a match expression against AudioExtractionCategoryType, 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.

AudioStandardGenerativeFieldType

When writing a match expression against AudioStandardGenerativeFieldType, 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.

BlueprintStage

When writing a match expression against BlueprintStage, 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.

BlueprintStageFilter

When writing a match expression against BlueprintStageFilter, 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.

DataAutomationProjectStage

When writing a match expression against DataAutomationProjectStage, 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.

DataAutomationProjectStageFilter

When writing a match expression against DataAutomationProjectStageFilter, 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.

DataAutomationProjectStatus

When writing a match expression against DataAutomationProjectStatus, 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.

DesiredModality

When writing a match expression against DesiredModality, 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.

DocumentExtractionGranularityType

When writing a match expression against DocumentExtractionGranularityType, 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.

DocumentOutputTextFormatType

When writing a match expression against DocumentOutputTextFormatType, 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.

ImageExtractionCategoryType

When writing a match expression against ImageExtractionCategoryType, 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.

ImageStandardGenerativeFieldType

When writing a match expression against ImageStandardGenerativeFieldType, 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.

ResourceOwner

When writing a match expression against ResourceOwner, 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.

State

When writing a match expression against State, 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.

Type

When writing a match expression against Type, 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.

VideoExtractionCategoryType

When writing a match expression against VideoExtractionCategoryType, 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.

VideoStandardGenerativeFieldType

When writing a match expression against VideoStandardGenerativeFieldType, 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.