// This file is @generated by prost-build.
/// Protocol buffer representing an arbitrarily large multi-dimensional array of
/// data, laid out in row-major format. To support tensors larger than the
/// maximum protocol buffer message size, the tensor payload may be split into
/// multiple chunks.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Tensor {
    /// The shape of the tensor. If empty, the data will be treated as a scalar.
    #[prost(int32, repeated, tag = "1")]
    pub shape: ::prost::alloc::vec::Vec<i32>,
    /// Data type for the elements in this tensor.
    #[prost(enumeration = "DataType", tag = "2")]
    pub data_type: i32,
    /// The payload for the tensor.
    #[prost(oneof = "tensor::Payload", tags = "3, 4")]
    pub payload: ::core::option::Option<tensor::Payload>,
}
/// Nested message and enum types in `Tensor`.
pub mod tensor {
    /// The payload for the tensor.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Payload {
        /// The raw data for the tensor. If present, the tensor is not split into
        /// chunks.
        #[prost(message, tag = "3")]
        Array(super::TensorChunk),
        /// The number of chunks the tensor is split into.
        #[prost(int64, tag = "4")]
        ChunkCount(i64),
    }
}
/// A single chunk of a tensor.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TensorChunk {
    /// Flattened tensor data. Data is laid out in row-major order.
    #[prost(bytes = "vec", tag = "1")]
    pub data: ::prost::alloc::vec::Vec<u8>,
    /// How the data is compressed. Compression is applied to each chunk
    /// independently.
    #[prost(enumeration = "CompressionType", tag = "2")]
    pub compression_type: i32,
}
/// The data type of the tensor.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DataType {
    /// Unspecified data type.
    Unspecified = 0,
    /// 16-bit "Brain Floating Point". See
    /// <https://en.wikipedia.org/wiki/Bfloat16_floating-point_format> for more
    /// details.
    Bfloat16 = 1,
    /// 16-bit floating point.
    Float16 = 11,
    /// 32-bit floating point.
    Float32 = 2,
    /// 64-bit floating point.
    Float64 = 3,
    /// 8-bit signed integer.
    Int8 = 4,
    /// 32-bit signed integer.
    Int32 = 5,
    /// 64-bit signed integer.
    Int64 = 6,
    /// 8-bit unsigned integer.
    Uint8 = 7,
    /// 32-bit unsigned integer.
    Uint32 = 8,
    /// 64-bit unsigned integer.
    Uint64 = 9,
    /// 8-bit boolean.
    Bool = 10,
}
impl DataType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "DATA_TYPE_UNSPECIFIED",
            Self::Bfloat16 => "DATA_TYPE_BFLOAT16",
            Self::Float16 => "DATA_TYPE_FLOAT16",
            Self::Float32 => "DATA_TYPE_FLOAT32",
            Self::Float64 => "DATA_TYPE_FLOAT64",
            Self::Int8 => "DATA_TYPE_INT8",
            Self::Int32 => "DATA_TYPE_INT32",
            Self::Int64 => "DATA_TYPE_INT64",
            Self::Uint8 => "DATA_TYPE_UINT8",
            Self::Uint32 => "DATA_TYPE_UINT32",
            Self::Uint64 => "DATA_TYPE_UINT64",
            Self::Bool => "DATA_TYPE_BOOL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DATA_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "DATA_TYPE_BFLOAT16" => Some(Self::Bfloat16),
            "DATA_TYPE_FLOAT16" => Some(Self::Float16),
            "DATA_TYPE_FLOAT32" => Some(Self::Float32),
            "DATA_TYPE_FLOAT64" => Some(Self::Float64),
            "DATA_TYPE_INT8" => Some(Self::Int8),
            "DATA_TYPE_INT32" => Some(Self::Int32),
            "DATA_TYPE_INT64" => Some(Self::Int64),
            "DATA_TYPE_UINT8" => Some(Self::Uint8),
            "DATA_TYPE_UINT32" => Some(Self::Uint32),
            "DATA_TYPE_UINT64" => Some(Self::Uint64),
            "DATA_TYPE_BOOL" => Some(Self::Bool),
            _ => None,
        }
    }
}
/// Compression type for the tensor data.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum CompressionType {
    /// No compression.
    None = 0,
    /// ZSTD compression.
    Zstd = 1,
}
impl CompressionType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::None => "COMPRESSION_TYPE_NONE",
            Self::Zstd => "COMPRESSION_TYPE_ZSTD",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "COMPRESSION_TYPE_NONE" => Some(Self::None),
            "COMPRESSION_TYPE_ZSTD" => Some(Self::Zstd),
            _ => None,
        }
    }
}
/// Message that represents a genomic interval.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Interval {
    /// The chromosome name, e.g., "chr1".
    #[prost(string, tag = "1")]
    pub chromosome: ::prost::alloc::string::String,
    /// 0-based start position.
    #[prost(int64, tag = "2")]
    pub start: i64,
    /// 0-based end position. Must be greater than or equal to start.
    #[prost(int64, tag = "3")]
    pub end: i64,
    /// The strand of the interval.
    #[prost(enumeration = "Strand", tag = "4")]
    pub strand: i32,
}
/// Message that represents a genomic variant/mutation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Variant {
    /// The chromosome name, e.g., "chr1".
    #[prost(string, tag = "1")]
    pub chromosome: ::prost::alloc::string::String,
    /// The 1-based position of the variant on the chromosome.
    #[prost(int64, tag = "2")]
    pub position: i64,
    /// The reference base(s) at the variant position. Normally this corresponds to
    /// the sequence in the reference genome. Must only contain characters "ACGTN".
    #[prost(string, tag = "3")]
    pub reference_bases: ::prost::alloc::string::String,
    /// The alternate base(s) that replace the reference. For example:
    /// If sequence="ACT", position=2, reference_bases="C", alternate_bases="TG",
    /// then the alternate sequence would be "ATGT'.
    #[prost(string, tag = "4")]
    pub alternate_bases: ::prost::alloc::string::String,
}
/// A single biological ontology term.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct OntologyTerm {
    /// The type of ontology this term belongs to.
    #[prost(enumeration = "OntologyType", tag = "1")]
    pub ontology_type: i32,
    /// The ID of the term within the ontology.
    #[prost(int64, tag = "2")]
    pub id: i64,
}
/// Message that represents a biological sample that is used in an experiment.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Biosample {
    /// Biosample type matching ENCODE conventions.
    #[prost(enumeration = "BiosampleType", tag = "1")]
    pub r#type: i32,
    /// The name of the biosample, e.g. "T-cell".
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Optional stage of the biosample, e.g. "adult".
    #[prost(string, optional, tag = "3")]
    pub stage: ::core::option::Option<::prost::alloc::string::String>,
}
/// Message containing metadata for a gene score.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GeneScorerMetadata {
    /// ENSEMBL gene identifier without version number, e.g. "ENSG00000100342".
    #[prost(string, tag = "1")]
    pub gene_id: ::prost::alloc::string::String,
    /// Optional HGNC gene symbol, e.g. "APOL1".
    #[prost(string, optional, tag = "3")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    /// Optional strand of the gene.
    #[prost(enumeration = "Strand", optional, tag = "2")]
    pub strand: ::core::option::Option<i32>,
    /// Optional gene biotype, e.g. "protein_coding" or "lncRNA".
    #[prost(string, optional, tag = "4")]
    pub r#type: ::core::option::Option<::prost::alloc::string::String>,
    /// Optional start position for junction scores.
    #[prost(int64, optional, tag = "5")]
    pub junction_start: ::core::option::Option<i64>,
    /// Optional end position for junction scores.
    #[prost(int64, optional, tag = "6")]
    pub junction_end: ::core::option::Option<i64>,
}
/// Message containing metadata for a track.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TrackMetadata {
    /// Name of the track.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Strand for the track.
    #[prost(enumeration = "Strand", tag = "2")]
    pub strand: i32,
    /// Ontology term for the track.
    #[prost(message, optional, tag = "3")]
    pub ontology_term: ::core::option::Option<OntologyTerm>,
    /// Biosample for the track.
    #[prost(message, optional, tag = "4")]
    pub biosample: ::core::option::Option<Biosample>,
    /// Optional assay for the track. e.g. "polyA plus RNA-seq".
    #[prost(string, optional, tag = "5")]
    pub assay: ::core::option::Option<::prost::alloc::string::String>,
    /// Optional histone mark for the track.
    #[prost(string, optional, tag = "9")]
    pub histone_mark_code: ::core::option::Option<::prost::alloc::string::String>,
    /// Optional transcription factor for the track.
    #[prost(string, optional, tag = "10")]
    pub transcription_factor_code: ::core::option::Option<
        ::prost::alloc::string::String,
    >,
    /// Optional GTEx tissue for the track.
    #[prost(string, optional, tag = "8")]
    pub gtex_tissue: ::core::option::Option<::prost::alloc::string::String>,
    /// Optional data source for the track. e.g. "encode".
    #[prost(string, optional, tag = "11")]
    pub data_source: ::core::option::Option<::prost::alloc::string::String>,
    /// Optional sequence reading endedness.
    #[prost(enumeration = "Endedness", optional, tag = "12")]
    pub endedness: ::core::option::Option<i32>,
    /// Optional boolean indicating whether the track is genetically modified.
    #[prost(bool, optional, tag = "13")]
    pub genetically_modified: ::core::option::Option<bool>,
    /// Optional mean of the non-zero values in the track.
    #[prost(float, optional, tag = "14")]
    pub nonzero_mean: ::core::option::Option<f32>,
}
/// Container for TrackMetadata.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TracksMetadata {
    /// Ordered list of metadata for each track.
    #[prost(message, repeated, tag = "1")]
    pub metadata: ::prost::alloc::vec::Vec<TrackMetadata>,
}
/// Message containing metadata for a splice junctions.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JunctionMetadata {
    /// Name of the junction track, e.g. "Brain_Cerebellum".
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Ontology term for the junction track.
    #[prost(message, optional, tag = "2")]
    pub ontology_term: ::core::option::Option<OntologyTerm>,
    /// Biosample for the junction track.
    #[prost(message, optional, tag = "3")]
    pub biosample: ::core::option::Option<Biosample>,
    /// Optional GTEx tissue for the junction track.
    #[prost(string, optional, tag = "4")]
    pub gtex_tissue: ::core::option::Option<::prost::alloc::string::String>,
    /// Optional data source for the track. e.g. "encode".
    #[prost(string, optional, tag = "5")]
    pub data_source: ::core::option::Option<::prost::alloc::string::String>,
    /// Optional assay for the track. e.g. "polyA plus RNA-seq".
    #[prost(string, optional, tag = "6")]
    pub assay: ::core::option::Option<::prost::alloc::string::String>,
}
/// Container for list of JunctionMetadata.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JunctionsMetadata {
    /// Ordered list of metadata for each junction.
    #[prost(message, repeated, tag = "1")]
    pub metadata: ::prost::alloc::vec::Vec<JunctionMetadata>,
}
/// Message for storing track values and metadata.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TrackData {
    /// Values for the track.
    #[prost(message, optional, tag = "1")]
    pub values: ::core::option::Option<Tensor>,
    /// Metadata for the track. The number of metadata elements must match the last
    /// dimension of the values tensor.
    #[prost(message, repeated, tag = "2")]
    pub metadata: ::prost::alloc::vec::Vec<TrackMetadata>,
    /// Resolution of the track data in base pairs.
    #[prost(int64, optional, tag = "3")]
    pub resolution: ::core::option::Option<i64>,
    /// Optional Interval representing the genomic region.
    #[prost(message, optional, tag = "4")]
    pub interval: ::core::option::Option<Interval>,
}
/// Message for storing splice junction values and metadata.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JunctionData {
    /// Values for the splice junction for each track.
    #[prost(message, optional, tag = "1")]
    pub values: ::core::option::Option<Tensor>,
    /// Metadata for the splice junction. The number of elements must match the
    /// last dimension of the values tensor.
    #[prost(message, repeated, tag = "2")]
    pub metadata: ::prost::alloc::vec::Vec<JunctionMetadata>,
    /// Predicted splice junctions. The number of elements must match the first
    /// dimensions of the values tensor.
    #[prost(message, repeated, tag = "3")]
    pub junctions: ::prost::alloc::vec::Vec<Interval>,
}
/// Message containing metadata for interval results.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IntervalMetadata {
    /// Genomic interval.
    #[prost(message, optional, tag = "1")]
    pub interval: ::core::option::Option<Interval>,
    /// Track metadata for the interval prediction.
    #[prost(message, repeated, tag = "2")]
    pub track_metadata: ::prost::alloc::vec::Vec<TrackMetadata>,
    /// Gene metadata for the interval prediction.
    #[prost(message, repeated, tag = "3")]
    pub gene_metadata: ::prost::alloc::vec::Vec<GeneScorerMetadata>,
}
/// Message for storing interval values and metadata.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IntervalData {
    /// Values for the interval.
    #[prost(message, optional, tag = "1")]
    pub values: ::core::option::Option<Tensor>,
    /// Metadata for the interval.
    #[prost(message, optional, tag = "2")]
    pub metadata: ::core::option::Option<IntervalMetadata>,
}
/// Message containing metadata for a variant prediction.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VariantMetadata {
    /// Genomic variant.
    #[prost(message, optional, tag = "1")]
    pub variant: ::core::option::Option<Variant>,
    /// Track metadata for the variant prediction.
    #[prost(message, repeated, tag = "2")]
    pub track_metadata: ::prost::alloc::vec::Vec<TrackMetadata>,
    /// Gene metadata for the variant prediction.
    #[prost(message, repeated, tag = "3")]
    pub gene_metadata: ::prost::alloc::vec::Vec<GeneScorerMetadata>,
}
/// Message for storing variant values and metadata.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VariantData {
    /// Values for the variant.
    #[prost(message, optional, tag = "1")]
    pub values: ::core::option::Option<Tensor>,
    /// Metadata for the variant.
    #[prost(message, optional, tag = "2")]
    pub metadata: ::core::option::Option<VariantMetadata>,
}
/// Message for storing model outputs for a single output type.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Output {
    /// The type of output.
    #[prost(enumeration = "OutputType", tag = "1")]
    pub output_type: i32,
    /// The payload for the output.
    #[prost(oneof = "output::Payload", tags = "2, 3, 4")]
    pub payload: ::core::option::Option<output::Payload>,
}
/// Nested message and enum types in `Output`.
pub mod output {
    /// The payload for the output.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Payload {
        /// Track data for the output. Used in all output types except
        /// OUTPUT_TYPE_SPLICE_JUNCTIONS.
        #[prost(message, tag = "2")]
        TrackData(super::TrackData),
        /// Raw predictions with no metadata.
        #[prost(message, tag = "3")]
        Data(super::Tensor),
        /// Junction data for the output. This is only set for
        /// OUTPUT_TYPE_SPLICE_JUNCTIONS.
        #[prost(message, tag = "4")]
        JunctionData(super::JunctionData),
    }
}
/// Message for storing score interval results.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScoreIntervalOutput {
    /// Score interval data.
    #[prost(message, optional, tag = "1")]
    pub interval_data: ::core::option::Option<IntervalData>,
}
/// Message for storing score variant results.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScoreVariantOutput {
    /// Score variant data.
    #[prost(message, optional, tag = "1")]
    pub variant_data: ::core::option::Option<VariantData>,
}
/// Interval scorer message for gene-mask scoring.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GeneMaskIntervalScorer {
    /// Requested output type.
    #[prost(enumeration = "OutputType", tag = "1")]
    pub requested_output: i32,
    /// Requested width.
    #[prost(int64, optional, tag = "2")]
    pub width: ::core::option::Option<i64>,
    /// Requested aggregation type.
    #[prost(enumeration = "IntervalAggregationType", tag = "3")]
    pub aggregation_type: i32,
}
/// Container message for all interval scorers.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct IntervalScorer {
    /// The interval scorer payload.
    #[prost(oneof = "interval_scorer::Scorer", tags = "1")]
    pub scorer: ::core::option::Option<interval_scorer::Scorer>,
}
/// Nested message and enum types in `IntervalScorer`.
pub mod interval_scorer {
    /// The interval scorer payload.
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Scorer {
        /// Gene mask scorer.
        #[prost(message, tag = "1")]
        GeneMask(super::GeneMaskIntervalScorer),
    }
}
/// Variant scorer message for center mask scoring.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CenterMaskScorer {
    /// The width of the mask around the variant.
    #[prost(int64, optional, tag = "1")]
    pub width: ::core::option::Option<i64>,
    /// The aggregation type.
    #[prost(enumeration = "AggregationType", tag = "2")]
    pub aggregation_type: i32,
    /// Requested output type.
    #[prost(enumeration = "OutputType", tag = "3")]
    pub requested_output: i32,
}
/// Variant scorer message for gene-mask scoring based on log fold change.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GeneMaskLfcScorer {
    /// Requested output type.
    #[prost(enumeration = "OutputType", tag = "1")]
    pub requested_output: i32,
}
/// Variant scorer message for gene-mask scoring based on active allele counts.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GeneMaskActiveScorer {
    /// Requested output type.
    #[prost(enumeration = "OutputType", tag = "1")]
    pub requested_output: i32,
}
/// Variant scorer message for gene-mask scoring for splicing.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GeneMaskSplicingScorer {
    /// The width of the mask around the variant.
    #[prost(int64, optional, tag = "1")]
    pub width: ::core::option::Option<i64>,
    /// Requested output type.
    #[prost(enumeration = "OutputType", tag = "2")]
    pub requested_output: i32,
}
/// Variant scorer message for polyadenylation QTLs (paQTLs).
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct PolyadenylationScorer {}
/// Variant scorer message for splice junction scoring.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SpliceJunctionScorer {}
/// Variant scorer message for contact map scoring.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ContactMapScorer {}
/// Container message for all variant scorers.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct VariantScorer {
    /// The variant scorer payload.
    #[prost(oneof = "variant_scorer::Scorer", tags = "1, 2, 3, 4, 5, 6, 7")]
    pub scorer: ::core::option::Option<variant_scorer::Scorer>,
}
/// Nested message and enum types in `VariantScorer`.
pub mod variant_scorer {
    /// The variant scorer payload.
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Scorer {
        /// Center mask scorer.
        #[prost(message, tag = "1")]
        CenterMask(super::CenterMaskScorer),
        /// Gene mask scorer based on log fold change.
        #[prost(message, tag = "2")]
        GeneMask(super::GeneMaskLfcScorer),
        /// Gene mask scorer for splicing.
        #[prost(message, tag = "3")]
        GeneMaskSplicing(super::GeneMaskSplicingScorer),
        /// Polyadenylation scorer.
        #[prost(message, tag = "4")]
        PaQtl(super::PolyadenylationScorer),
        /// Splice junction scorer.
        #[prost(message, tag = "5")]
        SpliceJunction(super::SpliceJunctionScorer),
        /// Contact map scorer.
        #[prost(message, tag = "6")]
        ContactMap(super::ContactMapScorer),
        /// Gene mask scorer based on active allele counts.
        #[prost(message, tag = "7")]
        GeneMaskActive(super::GeneMaskActiveScorer),
    }
}
/// Message containing metadata for an output type.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OutputMetadata {
    /// The output type.
    #[prost(enumeration = "OutputType", tag = "1")]
    pub output_type: i32,
    /// The payload for the output metadata.
    #[prost(oneof = "output_metadata::Payload", tags = "2, 3")]
    pub payload: ::core::option::Option<output_metadata::Payload>,
}
/// Nested message and enum types in `OutputMetadata`.
pub mod output_metadata {
    /// The payload for the output metadata.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Payload {
        /// Track metadata for the output. Used in all output types except
        /// OUTPUT_TYPE_SPLICE_JUNCTIONS.
        #[prost(message, tag = "2")]
        Tracks(super::TracksMetadata),
        /// Junction metadata for the output. This is only set for
        /// OUTPUT_TYPE_SPLICE_JUNCTIONS.
        #[prost(message, tag = "3")]
        Junctions(super::JunctionsMetadata),
    }
}
/// Defines the possible strands for a DNA sequence.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Strand {
    /// Unspecified strand.
    Unspecified = 0,
    /// The forward strand (5' to 3')
    Positive = 1,
    /// The reverse strand (3' to 5')
    Negative = 2,
    /// The strand is not specified.
    Unstranded = 3,
}
impl Strand {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "STRAND_UNSPECIFIED",
            Self::Positive => "STRAND_POSITIVE",
            Self::Negative => "STRAND_NEGATIVE",
            Self::Unstranded => "STRAND_UNSTRANDED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "STRAND_UNSPECIFIED" => Some(Self::Unspecified),
            "STRAND_POSITIVE" => Some(Self::Positive),
            "STRAND_NEGATIVE" => Some(Self::Negative),
            "STRAND_UNSTRANDED" => Some(Self::Unstranded),
            _ => None,
        }
    }
}
/// Supported ontology types.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum OntologyType {
    /// Unspecified ontology type.
    Unspecified = 0,
    /// Cell Line Ontology.
    Clo = 1,
    /// Uber-anatomy ontology.
    Uberon = 2,
    /// Cell Ontology.
    Cl = 3,
    /// Experimental Factor Ontology.
    Efo = 4,
    /// New Term Requested.
    Ntr = 5,
}
impl OntologyType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "ONTOLOGY_TYPE_UNSPECIFIED",
            Self::Clo => "ONTOLOGY_TYPE_CLO",
            Self::Uberon => "ONTOLOGY_TYPE_UBERON",
            Self::Cl => "ONTOLOGY_TYPE_CL",
            Self::Efo => "ONTOLOGY_TYPE_EFO",
            Self::Ntr => "ONTOLOGY_TYPE_NTR",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "ONTOLOGY_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "ONTOLOGY_TYPE_CLO" => Some(Self::Clo),
            "ONTOLOGY_TYPE_UBERON" => Some(Self::Uberon),
            "ONTOLOGY_TYPE_CL" => Some(Self::Cl),
            "ONTOLOGY_TYPE_EFO" => Some(Self::Efo),
            "ONTOLOGY_TYPE_NTR" => Some(Self::Ntr),
            _ => None,
        }
    }
}
/// Biosample type matching ENCODE conventions. See
/// <https://www.encodeproject.org/profiles/biosample_type.>
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum BiosampleType {
    /// Unspecified biosample type.
    Unspecified = 0,
    /// Primary cell sample.
    PrimaryCell = 1,
    /// In-vitro differentiated cell sample.
    InVitroDifferentiatedCells = 2,
    /// Cell line sample.
    CellLine = 3,
    /// Tissue sample.
    Tissue = 4,
    /// Technical sample.
    TechnicalSample = 5,
    /// Organoid sample.
    Organoid = 6,
}
impl BiosampleType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "BIOSAMPLE_TYPE_UNSPECIFIED",
            Self::PrimaryCell => "BIOSAMPLE_TYPE_PRIMARY_CELL",
            Self::InVitroDifferentiatedCells => {
                "BIOSAMPLE_TYPE_IN_VITRO_DIFFERENTIATED_CELLS"
            }
            Self::CellLine => "BIOSAMPLE_TYPE_CELL_LINE",
            Self::Tissue => "BIOSAMPLE_TYPE_TISSUE",
            Self::TechnicalSample => "BIOSAMPLE_TYPE_TECHNICAL_SAMPLE",
            Self::Organoid => "BIOSAMPLE_TYPE_ORGANOID",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "BIOSAMPLE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "BIOSAMPLE_TYPE_PRIMARY_CELL" => Some(Self::PrimaryCell),
            "BIOSAMPLE_TYPE_IN_VITRO_DIFFERENTIATED_CELLS" => {
                Some(Self::InVitroDifferentiatedCells)
            }
            "BIOSAMPLE_TYPE_CELL_LINE" => Some(Self::CellLine),
            "BIOSAMPLE_TYPE_TISSUE" => Some(Self::Tissue),
            "BIOSAMPLE_TYPE_TECHNICAL_SAMPLE" => Some(Self::TechnicalSample),
            "BIOSAMPLE_TYPE_ORGANOID" => Some(Self::Organoid),
            _ => None,
        }
    }
}
/// Enumeration of all the available types of outputs.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum OutputType {
    /// Unspecified output type.
    Unspecified = 0,
    /// ATAC-seq tracks capturing chromatin accessibility.
    Atac = 1,
    /// CAGE (Cap Analysis of Gene Expression) tracks capturing gene expression.
    Cage = 2,
    /// DNase I hypersensitive site tracks capturing chromatin accessibility.
    Dnase = 3,
    /// RNA sequencing tracks capturing gene expression.
    RnaSeq = 4,
    /// ChIP-seq tracks capturing histone modifications.
    ChipHistone = 5,
    /// ChIP-seq tracks capturing transcription factor binding.
    ChipTf = 6,
    /// Splice site tracks capturing donor and acceptor splice sites.
    SpliceSites = 7,
    /// Splice site usage tracks capturing the fraction of the time that each
    /// splice site is used.
    SpliceSiteUsage = 8,
    /// Splice junction tracks capturing split read RNA-seq counts for each
    /// junction.
    SpliceJunctions = 9,
    /// Contact map tracks capturing 3D chromatin contact probabilities.
    ContactMaps = 11,
    /// Precision Run-On sequencing and capping, used to measure gene expression.
    Procap = 12,
}
impl OutputType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "OUTPUT_TYPE_UNSPECIFIED",
            Self::Atac => "OUTPUT_TYPE_ATAC",
            Self::Cage => "OUTPUT_TYPE_CAGE",
            Self::Dnase => "OUTPUT_TYPE_DNASE",
            Self::RnaSeq => "OUTPUT_TYPE_RNA_SEQ",
            Self::ChipHistone => "OUTPUT_TYPE_CHIP_HISTONE",
            Self::ChipTf => "OUTPUT_TYPE_CHIP_TF",
            Self::SpliceSites => "OUTPUT_TYPE_SPLICE_SITES",
            Self::SpliceSiteUsage => "OUTPUT_TYPE_SPLICE_SITE_USAGE",
            Self::SpliceJunctions => "OUTPUT_TYPE_SPLICE_JUNCTIONS",
            Self::ContactMaps => "OUTPUT_TYPE_CONTACT_MAPS",
            Self::Procap => "OUTPUT_TYPE_PROCAP",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "OUTPUT_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "OUTPUT_TYPE_ATAC" => Some(Self::Atac),
            "OUTPUT_TYPE_CAGE" => Some(Self::Cage),
            "OUTPUT_TYPE_DNASE" => Some(Self::Dnase),
            "OUTPUT_TYPE_RNA_SEQ" => Some(Self::RnaSeq),
            "OUTPUT_TYPE_CHIP_HISTONE" => Some(Self::ChipHistone),
            "OUTPUT_TYPE_CHIP_TF" => Some(Self::ChipTf),
            "OUTPUT_TYPE_SPLICE_SITES" => Some(Self::SpliceSites),
            "OUTPUT_TYPE_SPLICE_SITE_USAGE" => Some(Self::SpliceSiteUsage),
            "OUTPUT_TYPE_SPLICE_JUNCTIONS" => Some(Self::SpliceJunctions),
            "OUTPUT_TYPE_CONTACT_MAPS" => Some(Self::ContactMaps),
            "OUTPUT_TYPE_PROCAP" => Some(Self::Procap),
            _ => None,
        }
    }
}
/// Enumeration of all the available organisms. Values relate to the NCBI
/// taxonomy ID.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Organism {
    /// Unspecified organism.
    Unspecified = 0,
    /// Human (Homo sapiens).
    HomoSapiens = 9606,
    /// Mouse (Mus musculus).
    MusMusculus = 10090,
}
impl Organism {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "ORGANISM_UNSPECIFIED",
            Self::HomoSapiens => "ORGANISM_HOMO_SAPIENS",
            Self::MusMusculus => "ORGANISM_MUS_MUSCULUS",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "ORGANISM_UNSPECIFIED" => Some(Self::Unspecified),
            "ORGANISM_HOMO_SAPIENS" => Some(Self::HomoSapiens),
            "ORGANISM_MUS_MUSCULUS" => Some(Self::MusMusculus),
            _ => None,
        }
    }
}
/// Enum indicating the type of interval scorer aggregation.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum IntervalAggregationType {
    /// Unspecified aggregation type.
    Unspecified = 0,
    /// Mean across positions.
    Mean = 1,
    /// Sum across positions.
    Sum = 2,
}
impl IntervalAggregationType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "INTERVAL_AGGREGATION_TYPE_UNSPECIFIED",
            Self::Mean => "INTERVAL_AGGREGATION_TYPE_MEAN",
            Self::Sum => "INTERVAL_AGGREGATION_TYPE_SUM",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "INTERVAL_AGGREGATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "INTERVAL_AGGREGATION_TYPE_MEAN" => Some(Self::Mean),
            "INTERVAL_AGGREGATION_TYPE_SUM" => Some(Self::Sum),
            _ => None,
        }
    }
}
/// Enum indicating the type of variant scorer aggregation.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AggregationType {
    /// Unspecified aggregation type.
    Unspecified = 0,
    /// Difference of means, i.e., mean(ALT) - mean(REF).
    DiffMean = 1,
    /// Difference of sums, i.e., sum(ALT) - sum(REF).
    DiffSum = 2,
    /// Log ratio of sums, i.e., log(sum(ALT) / sum(REF)).
    LogRatioSum = 3,
}
impl AggregationType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "AGGREGATION_TYPE_UNSPECIFIED",
            Self::DiffMean => "AGGREGATION_TYPE_DIFF_MEAN",
            Self::DiffSum => "AGGREGATION_TYPE_DIFF_SUM",
            Self::LogRatioSum => "AGGREGATION_TYPE_LOG_RATIO_SUM",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "AGGREGATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "AGGREGATION_TYPE_DIFF_MEAN" => Some(Self::DiffMean),
            "AGGREGATION_TYPE_DIFF_SUM" => Some(Self::DiffSum),
            "AGGREGATION_TYPE_LOG_RATIO_SUM" => Some(Self::LogRatioSum),
            _ => None,
        }
    }
}
/// Enum indicating read endedness.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Endedness {
    /// Unspecified.
    Unspecified = 0,
    /// Single end reads.
    Single = 1,
    /// Paired end reads.
    Paired = 2,
}
impl Endedness {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "ENDEDNESS_UNSPECIFIED",
            Self::Single => "ENDEDNESS_SINGLE",
            Self::Paired => "ENDEDNESS_PAIRED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "ENDEDNESS_UNSPECIFIED" => Some(Self::Unspecified),
            "ENDEDNESS_SINGLE" => Some(Self::Single),
            "ENDEDNESS_PAIRED" => Some(Self::Paired),
            _ => None,
        }
    }
}
/// Request message for predicting a sequence.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PredictSequenceRequest {
    /// DNA sequence to make prediction for. Must only contain characters "ACGTN".
    #[prost(string, tag = "1")]
    pub sequence: ::prost::alloc::string::String,
    /// Organism to use for the prediction.
    #[prost(enumeration = "Organism", tag = "2")]
    pub organism: i32,
    /// Ontology terms to generate predictions for. If empty returns all
    /// ontologies.
    #[prost(message, repeated, tag = "3")]
    pub ontology_terms: ::prost::alloc::vec::Vec<OntologyTerm>,
    /// Output types to generate predictions for.
    #[prost(enumeration = "OutputType", repeated, tag = "4")]
    pub requested_outputs: ::prost::alloc::vec::Vec<i32>,
    /// Model version to use.
    #[prost(string, tag = "5")]
    pub model_version: ::prost::alloc::string::String,
}
/// Response message for predicting a sequence.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PredictSequenceResponse {
    /// The payload for the response.
    #[prost(oneof = "predict_sequence_response::Payload", tags = "1, 2")]
    pub payload: ::core::option::Option<predict_sequence_response::Payload>,
}
/// Nested message and enum types in `PredictSequenceResponse`.
pub mod predict_sequence_response {
    /// The payload for the response.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Payload {
        /// Output for a single output type.
        #[prost(message, tag = "1")]
        Output(super::Output),
        /// Tensor chunk related to the last output message received. It is an error
        /// to receive a tensor chunk without a previous output message.
        #[prost(message, tag = "2")]
        TensorChunk(super::TensorChunk),
    }
}
/// Request message for predicting an interval.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PredictIntervalRequest {
    /// DNA interval to make prediction for.
    #[prost(message, optional, tag = "1")]
    pub interval: ::core::option::Option<Interval>,
    /// Organism to use for the prediction.
    #[prost(enumeration = "Organism", tag = "2")]
    pub organism: i32,
    /// Output types to generate predictions for.
    #[prost(enumeration = "OutputType", repeated, tag = "3")]
    pub requested_outputs: ::prost::alloc::vec::Vec<i32>,
    /// Ontology terms to generate predictions for. If empty returns all
    /// ontologies.
    #[prost(message, repeated, tag = "4")]
    pub ontology_terms: ::prost::alloc::vec::Vec<OntologyTerm>,
    /// Model version to use.
    #[prost(string, tag = "5")]
    pub model_version: ::prost::alloc::string::String,
}
/// Response message for predicting an interval.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PredictIntervalResponse {
    /// The payload for the response.
    #[prost(oneof = "predict_interval_response::Payload", tags = "1, 2")]
    pub payload: ::core::option::Option<predict_interval_response::Payload>,
}
/// Nested message and enum types in `PredictIntervalResponse`.
pub mod predict_interval_response {
    /// The payload for the response.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Payload {
        /// Output for a single output type.
        #[prost(message, tag = "1")]
        Output(super::Output),
        /// Tensor chunk related to the last output message received. It is an error
        /// to receive a tensor chunk without a previous output message.
        #[prost(message, tag = "2")]
        TensorChunk(super::TensorChunk),
    }
}
/// Request message for predicting a variant.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PredictVariantRequest {
    /// DNA interval to make prediction for.
    #[prost(message, optional, tag = "1")]
    pub interval: ::core::option::Option<Interval>,
    /// DNA variant to make prediction for.
    #[prost(message, optional, tag = "2")]
    pub variant: ::core::option::Option<Variant>,
    /// Organism to use for the prediction.
    #[prost(enumeration = "Organism", tag = "3")]
    pub organism: i32,
    /// Output types to generate predictions for.
    #[prost(enumeration = "OutputType", repeated, tag = "4")]
    pub requested_outputs: ::prost::alloc::vec::Vec<i32>,
    /// Ontology terms to generate predictions for. If empty returns all
    /// ontologies.
    #[prost(message, repeated, tag = "5")]
    pub ontology_terms: ::prost::alloc::vec::Vec<OntologyTerm>,
    /// Model version to use.
    #[prost(string, tag = "6")]
    pub model_version: ::prost::alloc::string::String,
}
/// Response message for predicting a variant.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PredictVariantResponse {
    /// The payload for the response.
    #[prost(oneof = "predict_variant_response::Payload", tags = "1, 2, 3")]
    pub payload: ::core::option::Option<predict_variant_response::Payload>,
}
/// Nested message and enum types in `PredictVariantResponse`.
pub mod predict_variant_response {
    /// The payload for the response.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Payload {
        /// Reference output for a single output type.
        #[prost(message, tag = "1")]
        ReferenceOutput(super::Output),
        /// Alternate output for a single output type.
        #[prost(message, tag = "2")]
        AlternateOutput(super::Output),
        /// Tensor chunk related to the last reference or alternate output message
        /// received. It is an error to receive a tensor chunk without a previous
        /// reference or alternate output message.
        #[prost(message, tag = "3")]
        TensorChunk(super::TensorChunk),
    }
}
/// Request message for scoring an interval.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScoreIntervalRequest {
    /// DNA interval to make prediction for.
    #[prost(message, optional, tag = "1")]
    pub interval: ::core::option::Option<Interval>,
    /// Organism to use for the prediction.
    #[prost(enumeration = "Organism", tag = "2")]
    pub organism: i32,
    /// Interval scorers to use for the prediction.
    #[prost(message, repeated, tag = "3")]
    pub interval_scorers: ::prost::alloc::vec::Vec<IntervalScorer>,
    /// Model version to use.
    #[prost(string, tag = "4")]
    pub model_version: ::prost::alloc::string::String,
}
/// Response message for scoring an interval.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScoreIntervalResponse {
    /// The payload for the response.
    #[prost(oneof = "score_interval_response::Payload", tags = "1, 2")]
    pub payload: ::core::option::Option<score_interval_response::Payload>,
}
/// Nested message and enum types in `ScoreIntervalResponse`.
pub mod score_interval_response {
    /// The payload for the response.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Payload {
        /// Score interval output.
        #[prost(message, tag = "1")]
        Output(super::ScoreIntervalOutput),
        /// Tensor chunk related to the last score interval output message received.
        /// It is an error to receice a tensor chunk without a previous output
        /// message.
        #[prost(message, tag = "2")]
        TensorChunk(super::TensorChunk),
    }
}
/// Request message for scoring a variant.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScoreVariantRequest {
    /// DNA interval to make prediction for.
    #[prost(message, optional, tag = "1")]
    pub interval: ::core::option::Option<Interval>,
    /// DNA variant to make prediction for.
    #[prost(message, optional, tag = "2")]
    pub variant: ::core::option::Option<Variant>,
    /// Organism to use for the prediction.
    #[prost(enumeration = "Organism", tag = "3")]
    pub organism: i32,
    /// Variant scorers to use for the prediction.
    #[prost(message, repeated, tag = "4")]
    pub variant_scorers: ::prost::alloc::vec::Vec<VariantScorer>,
    /// Model version to use.
    #[prost(string, tag = "5")]
    pub model_version: ::prost::alloc::string::String,
}
/// Response message for scoring a variant.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScoreVariantResponse {
    /// The payload for the response.
    #[prost(oneof = "score_variant_response::Payload", tags = "1, 2")]
    pub payload: ::core::option::Option<score_variant_response::Payload>,
}
/// Nested message and enum types in `ScoreVariantResponse`.
pub mod score_variant_response {
    /// The payload for the response.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Payload {
        /// Score variant output.
        #[prost(message, tag = "1")]
        Output(super::ScoreVariantOutput),
        /// Tensor chunk related to the last score variant output message received.
        /// It is an error to receive a tensor chunk without a previous output
        /// message.
        #[prost(message, tag = "2")]
        TensorChunk(super::TensorChunk),
    }
}
/// Request message for scoring an in-silico mutagenesis (ISM) interval.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScoreIsmVariantRequest {
    /// DNA interval to make the prediction for.
    #[prost(message, optional, tag = "1")]
    pub interval: ::core::option::Option<Interval>,
    /// ISM interval to make the prediction for.
    #[prost(message, optional, tag = "2")]
    pub ism_interval: ::core::option::Option<Interval>,
    /// Organism to use for the prediction.
    #[prost(enumeration = "Organism", tag = "3")]
    pub organism: i32,
    /// Variant scorers to use for the prediction.
    #[prost(message, repeated, tag = "4")]
    pub variant_scorers: ::prost::alloc::vec::Vec<VariantScorer>,
    /// Optional variant applied to the reference interval. If provided, the
    /// alternate allele is used for in-silico mutagenesis, otherwise the
    /// unaltered reference sequence is used.
    #[prost(message, optional, tag = "6")]
    pub interval_variant: ::core::option::Option<Variant>,
    /// Model version to use.
    #[prost(string, tag = "5")]
    pub model_version: ::prost::alloc::string::String,
}
/// Response message for scoring an in-silico mutagenesis (ISM) interval.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScoreIsmVariantResponse {
    /// The payload for the response.
    #[prost(oneof = "score_ism_variant_response::Payload", tags = "1, 2")]
    pub payload: ::core::option::Option<score_ism_variant_response::Payload>,
}
/// Nested message and enum types in `ScoreIsmVariantResponse`.
pub mod score_ism_variant_response {
    /// The payload for the response.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Payload {
        /// Score variant output.
        #[prost(message, tag = "1")]
        Output(super::ScoreVariantOutput),
        /// Tensor chunk related to the last score variant output message received.
        /// It is an error to receive a tensor chunk without a previous output
        /// message.
        #[prost(message, tag = "2")]
        TensorChunk(super::TensorChunk),
    }
}
/// Request message for getting metadata for an organism.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct MetadataRequest {
    /// The organism we should return metadata for.
    #[prost(enumeration = "Organism", tag = "1")]
    pub organism: i32,
}
/// Response message for getting metadata for an organism.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MetadataResponse {
    /// The metadata for each output type.
    #[prost(message, repeated, tag = "1")]
    pub output_metadata: ::prost::alloc::vec::Vec<OutputMetadata>,
}
/// Generated client implementations.
pub mod dna_model_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for making predictions with DNA models.
    #[derive(Debug, Clone)]
    pub struct DnaModelServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl DnaModelServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> DnaModelServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> DnaModelServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            DnaModelServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Makes a prediction for DNA sequence.
        pub async fn predict_sequence(
            &mut self,
            request: impl tonic::IntoStreamingRequest<
                Message = super::PredictSequenceRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::PredictSequenceResponse>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.gdm.gdmscience.alphagenome.v1main.DnaModelService/PredictSequence",
            );
            let mut req = request.into_streaming_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.gdm.gdmscience.alphagenome.v1main.DnaModelService",
                        "PredictSequence",
                    ),
                );
            self.inner.streaming(req, path, codec).await
        }
        /// Make prediction for a single genomic interval.
        pub async fn predict_interval(
            &mut self,
            request: impl tonic::IntoStreamingRequest<
                Message = super::PredictIntervalRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::PredictIntervalResponse>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.gdm.gdmscience.alphagenome.v1main.DnaModelService/PredictInterval",
            );
            let mut req = request.into_streaming_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.gdm.gdmscience.alphagenome.v1main.DnaModelService",
                        "PredictInterval",
                    ),
                );
            self.inner.streaming(req, path, codec).await
        }
        /// Make variant effect predictions for a genomic interval.
        pub async fn predict_variant(
            &mut self,
            request: impl tonic::IntoStreamingRequest<
                Message = super::PredictVariantRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::PredictVariantResponse>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.gdm.gdmscience.alphagenome.v1main.DnaModelService/PredictVariant",
            );
            let mut req = request.into_streaming_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.gdm.gdmscience.alphagenome.v1main.DnaModelService",
                        "PredictVariant",
                    ),
                );
            self.inner.streaming(req, path, codec).await
        }
        /// Score a genomic interval.
        pub async fn score_interval(
            &mut self,
            request: impl tonic::IntoStreamingRequest<
                Message = super::ScoreIntervalRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::ScoreIntervalResponse>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.gdm.gdmscience.alphagenome.v1main.DnaModelService/ScoreInterval",
            );
            let mut req = request.into_streaming_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.gdm.gdmscience.alphagenome.v1main.DnaModelService",
                        "ScoreInterval",
                    ),
                );
            self.inner.streaming(req, path, codec).await
        }
        /// Score a variant for a genomic interval.
        pub async fn score_variant(
            &mut self,
            request: impl tonic::IntoStreamingRequest<
                Message = super::ScoreVariantRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::ScoreVariantResponse>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.gdm.gdmscience.alphagenome.v1main.DnaModelService/ScoreVariant",
            );
            let mut req = request.into_streaming_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.gdm.gdmscience.alphagenome.v1main.DnaModelService",
                        "ScoreVariant",
                    ),
                );
            self.inner.streaming(req, path, codec).await
        }
        /// Score ISM variant effect predictions for a genomic interval.
        pub async fn score_ism_variant(
            &mut self,
            request: impl tonic::IntoStreamingRequest<
                Message = super::ScoreIsmVariantRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::ScoreIsmVariantResponse>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.gdm.gdmscience.alphagenome.v1main.DnaModelService/ScoreIsmVariant",
            );
            let mut req = request.into_streaming_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.gdm.gdmscience.alphagenome.v1main.DnaModelService",
                        "ScoreIsmVariant",
                    ),
                );
            self.inner.streaming(req, path, codec).await
        }
        /// Get metadata for the model.
        pub async fn get_metadata(
            &mut self,
            request: impl tonic::IntoRequest<super::MetadataRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::MetadataResponse>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.gdm.gdmscience.alphagenome.v1main.DnaModelService/GetMetadata",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.gdm.gdmscience.alphagenome.v1main.DnaModelService",
                        "GetMetadata",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
    }
}
