Module aws_sdk_omics::model

Data structures used by operation inputs/outputs. Documentation on these types is copied from the model.

Modules

activate_read_set_filter

See ActivateReadSetFilter.

activate_read_set_job_item

See ActivateReadSetJobItem.

activate_read_set_source_item

See ActivateReadSetSourceItem.

annotation_import_item_detail

See AnnotationImportItemDetail.

annotation_import_item_source

See AnnotationImportItemSource.

annotation_import_job_item

See AnnotationImportJobItem.

annotation_store_item

See AnnotationStoreItem.

export_read_set

See ExportReadSet.

export_read_set_detail

See ExportReadSetDetail.

export_read_set_filter

See ExportReadSetFilter.

export_read_set_job_detail

See ExportReadSetJobDetail.

file_information

See FileInformation.

import_read_set_filter

See ImportReadSetFilter.

import_read_set_job_item

See ImportReadSetJobItem.

import_read_set_source_item

See ImportReadSetSourceItem.

import_reference_filter

See ImportReferenceFilter.

import_reference_job_item

See ImportReferenceJobItem.

import_reference_source_item

See ImportReferenceSourceItem.

list_annotation_import_jobs_filter

See ListAnnotationImportJobsFilter.

list_annotation_stores_filter

See ListAnnotationStoresFilter.

list_variant_import_jobs_filter

See ListVariantImportJobsFilter.

list_variant_stores_filter

See ListVariantStoresFilter.

read_options

See ReadOptions.

read_set_batch_error

See ReadSetBatchError.

read_set_files

See ReadSetFiles.

read_set_filter

See ReadSetFilter.

read_set_list_item

See ReadSetListItem.

reference_files

See ReferenceFiles.

reference_filter

See ReferenceFilter.

reference_list_item

See ReferenceListItem.

reference_store_detail

See ReferenceStoreDetail.

reference_store_filter

See ReferenceStoreFilter.

run_group_list_item

See RunGroupListItem.

run_list_item

See RunListItem.

sequence_information

See SequenceInformation.

sequence_store_detail

See SequenceStoreDetail.

sequence_store_filter

See SequenceStoreFilter.

source_files

See SourceFiles.

sse_config

See SseConfig.

start_read_set_activation_job_source_item

See StartReadSetActivationJobSourceItem.

start_read_set_import_job_source_item

See StartReadSetImportJobSourceItem.

start_reference_import_job_source_item

See StartReferenceImportJobSourceItem.

task_list_item

See TaskListItem.

tsv_options

See TsvOptions.

tsv_store_options

See TsvStoreOptions.

variant_import_item_detail

See VariantImportItemDetail.

variant_import_item_source

See VariantImportItemSource.

variant_import_job_item

See VariantImportJobItem.

variant_store_item

See VariantStoreItem.

vcf_options

See VcfOptions.

workflow_list_item

See WorkflowListItem.

workflow_parameter

See WorkflowParameter.

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.

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.

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.

ListAnnotationStoresFilter

A filter for annotation stores.

ListVariantImportJobsFilter

A filter for variant import jobs.

ListVariantStoresFilter

A filter for variant stores.

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.

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.

RunGroupListItem

A run group.

RunListItem

A workflow run.

SequenceInformation

Details about a sequence.

SequenceStoreDetail

Details about a sequence store.

SequenceStoreFilter

A filter for a sequence store.

SourceFiles

Source files for a sequence.

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.

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.

WorkflowListItem

A workflow.

WorkflowParameter

A workflow parameter.

Enums

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.

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.

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.

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.

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.

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.

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.

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.

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.