Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that Amazon Omics can respond with.

Structs

ActivateReadSetFilter

A read set activation job filter.

ActivateReadSetJobItem

A read set activation job.

ActivateReadSetSourceItem

A source for a read set activation job.

AnnotationImportItemDetail

Details about an imported annotation item.

AnnotationImportItemSource

A source for an annotation import job.

AnnotationImportJobItem

An annotation import job.

AnnotationStoreItem

An annotation store.

AnnotationStoreVersionItem

Annotation store versions.

CompleteReadSetUploadPartListItem

Part of the response to the CompleteReadSetUpload API, including metadata.

ContainerRegistryMap

Use a container registry map to specify mappings between the ECR private repository and one or more upstream registries. For more information, see Container images in the Amazon Web Services HealthOmics User Guide.

DefinitionRepository

Contains information about a source code repository that hosts the workflow definition files.

DefinitionRepositoryDetails

Contains detailed information about the source code repository that hosts the workflow definition files.

ETag

The entity tag (ETag) is a hash of the object representing its semantic content.

ExportReadSet

A read set.

ExportReadSetDetail

Details about a read set.

ExportReadSetFilter

An read set export job filter.

ExportReadSetJobDetail

Details about a read set export job.

FileInformation

Details about a file.

Filter

Use filters to return a subset of resources. You can define filters for specific parameters, such as the resource status.

ImageDetails

Information about the container image used for a task.

ImageMapping

Specifies image mappings that workflow tasks can use. For example, you can replace all the task references of a public image to use an equivalent image in your private ECR repository. You can use image mappings with upstream registries that don't support pull through cache. You need to manually synchronize the upstream registry with your private repository.

ImportReadSetFilter

A filter for import read set jobs.

ImportReadSetJobItem

An import read set job.

ImportReadSetSourceItem

A source for an import read set job.

ImportReferenceFilter

A filter for import references.

ImportReferenceJobItem

An import reference job.

ImportReferenceSourceItem

An genome reference source.

ListAnnotationImportJobsFilter

A filter for annotation import jobs.

ListAnnotationStoreVersionsFilter

Use filters to focus the returned annotation store versions on a specific parameter, such as the status of the annotation store.

ListAnnotationStoresFilter

A filter for annotation stores.

ListVariantImportJobsFilter

A filter for variant import jobs.

ListVariantStoresFilter

A filter for variant stores.

MultipartReadSetUploadListItem

Part of the response to ListMultipartReadSetUploads, excluding completed and aborted multipart uploads.

ReadOptions

Read options for an annotation import job.

ReadSetBatchError

An error from a batch read set operation.

ReadSetFiles

Files in a read set.

ReadSetFilter

A filter for read sets.

ReadSetListItem

A read set.

ReadSetS3Access

The S3 URI for each read set file.

ReadSetUploadPartListFilter

Filter settings that select for read set upload parts of interest.

ReadSetUploadPartListItem

The metadata of a single part of a file that was added to a multipart upload. A list of these parts is returned in the response to the ListReadSetUploadParts API.

ReferenceFiles

A set of genome reference files.

ReferenceFilter

A filter for references.

ReferenceListItem

A genome reference.

ReferenceStoreDetail

Details about a reference store.

ReferenceStoreFilter

A filter for reference stores.

RegistryMapping

If you are using the ECR pull through cache feature, the registry mapping maps between the ECR repository and the upstream registry where container images are pulled and synchronized.

RunCacheListItem

List entry for one run cache.

RunGroupListItem

A run group.

RunListItem

A workflow run.

RunLogLocation

The URI for the run log.

S3AccessConfig

S3 access configuration parameters.

SequenceInformation

Details about a sequence.

SequenceStoreDetail

Details about a sequence store.

SequenceStoreFilter

A filter for a sequence store.

SequenceStoreS3Access

The S3 access metadata of the sequence store.

ShareDetails

The details of a resource share.

SourceFiles

Source files for a sequence.

SourceReference

Contains information about the source reference in a code repository, such as a branch, tag, or commit.

SseConfig

Server-side encryption (SSE) settings for a store.

StartReadSetActivationJobSourceItem

A source for a read set activation job.

StartReadSetImportJobSourceItem

A source for a read set import job.

StartReferenceImportJobSourceItem

A source for a reference import job.

TaskListItem

A workflow run task.

TsvOptions

Formatting options for a TSV file.

TsvStoreOptions

File settings for a TSV store.

TsvVersionOptions

The options for a TSV file.

VariantImportItemDetail

Details about an imported variant item.

VariantImportItemSource

A imported variant item's source.

VariantImportJobItem

A variant import job.

VariantStoreItem

A variant store.

VcfOptions

Formatting options for a VCF file.

VersionDeleteError

The error preventing deletion of the annotation store version.

WorkflowListItem

A workflow.

WorkflowParameter

A workflow parameter.

WorkflowVersionListItem

A list of workflow version items.

Enums

Accelerators

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

AnnotationType

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

CacheBehavior

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

CreationType

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

ETagAlgorithm

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

ETagAlgorithmFamily

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

EncryptionType

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

FileType

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

FormatOptions

Formatting options for a file.

FormatToHeaderKey

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

JobStatus

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

ReadSetActivationJobItemStatus

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

ReadSetActivationJobStatus

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

ReadSetExportJobItemStatus

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

ReadSetExportJobStatus

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

ReadSetFile

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

ReadSetImportJobItemStatus

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

ReadSetImportJobStatus

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

ReadSetPartSource

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

ReadSetStatus

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

ReferenceCreationType

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

ReferenceFile

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

ReferenceImportJobItemStatus

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

ReferenceImportJobStatus

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

ReferenceItem

A genome reference.

ReferenceStatus

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

RunCacheStatus

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

RunExport

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

RunLogLevel

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

RunRetentionMode

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

RunStatus

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

SchemaValueType

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

SequenceStoreStatus

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

ShareResourceType

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

ShareStatus

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

SourceReferenceType

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

StorageType

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

StoreFormat

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

StoreOptions

Settings for a store.

StoreStatus

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

StoreType

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

TaskStatus

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

VersionOptions

The options for an annotation store version.

VersionStatus

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

WorkflowEngine

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

WorkflowExport

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

WorkflowStatus

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

WorkflowType

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