Module aws_sdk_omics::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.

• 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 focus the returned annotation store versions on a specific parameter, such as the status of the annotation store.

• 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.

• 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.

• RunGroupListItem

  A run group.

• RunListItem

  A workflow run.

• RunLogLocation

  The URI for the run log.

• SequenceInformation

  Details about a sequence.

• SequenceStoreDetail

  Details about a sequence store.

• SequenceStoreFilter

  A filter for a sequence store.

• ShareDetails

  The details of a share.

• 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.

• 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.

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.
• 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.
• 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.
• 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.
• 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.
• 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.
• 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.
• 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.