src/objects/varrep/varrep.asn

NCBI-VariationIRep DEFINITIONS AUTOMATIC TAGS ::=
BEGIN 


--EXPORTS VariantExpression, SimpleVariant;

VariantExpression ::= SEQUENCE {
    input-expr VisibleString, -- contains the input expression to be parsed
    reference-id VisibleString, -- contains the accession id or other identifier for the reference sequence
    sequence-variant SequenceVariant
}


SequenceVariant ::= SEQUENCE {
    seqtype VariantSeqType,
    subvariants SEQUENCE OF Variant,
    complex INTEGER {
        mosaic  (1), 
        chimera (2)
    } OPTIONAL
}


Variant ::= CHOICE {
    simple SimpleVariant, 
    special SpecialVariant
}


VariantSeqType ::= INTEGER {
    g (0), --genomic
    m (1), --mitochondrial
    c (2), --coding
    r (3), --rna
    n (4), --non-coding rna
    p (5), --protein
    u (6)  --unknown
}


SpecialVariant ::= INTEGER { 
    unknown            (0), -- ?
    not-analyzed       (1), -- (?) Not sure about this
    nochange           (2), -- =
    nochange-expected  (3), -- (=)
    noseq              (4), -- 0
    noseq-expected     (5), -- 0?
    splice-expected    (6), -- spl?
    splice-possible    (7)  -- (spl?) 
}


-- SimpleVarSeq is deprecated and should go
SimpleVariantSeq ::= SEQUENCE { 
    variants SEQUENCE OF SimpleVariant,  
    sisters BOOLEAN DEFAULT FALSE,
    fuzzy BOOLEAN DEFAULT FALSE
}


SimpleVariant ::= SEQUENCE {
    type  CHOICE {
        na-identity NaIdentity,
        na-sub NaSub,
        prot-sub ProteinSub,
        prot-silent AaLocation,
        del Deletion,
        dup Duplication,
        inv Inversion,
        ins Insertion,
        conv Conversion,
        delins Delins,
        repeat Repeat, --short-sequence repeat (ssr)
        prot-ext ProteinExtension,
        frameshift Frameshift
    },
    fuzzy BOOLEAN DEFAULT FALSE
}


Delins ::= SEQUENCE {
    loc SeqLocation,
    deleted-raw-seq VisibleString OPTIONAL, -- can optionally specify the deleted sequence
    inserted-seq-info CHOICE {
        identifier VisibleString, -- A sequence identifier (e.g. an accession id)
        raw-seq VisibleString, -- The actual nucleotide / amino-acid sequence
        count Count, -- The number of elements inserted
        subseq Subsequence -- A subsequence specified by an id, type descriptor, and a range
    }
}


NaSub ::= SEQUENCE {
    loc NtLocation,
    initial VisibleString,
    final VisibleString
}

NaIdentity ::= SEQUENCE {
    loc NtLocation,
    nucleotide VisibleString OPTIONAL
}


ProteinSub ::= SEQUENCE {
    type INTEGER {
        missense(0),
        nonsense(1),
        unknown(2)
    },
    initial AaSite,
    final VisibleString OPTIONAL
}


ProteinExtension ::= CHOICE {
    nterm-ext NtermExtension,
    cterm-ext CtermExtension
}


NtermExtension ::= SEQUENCE {
    newStart Count,
    newAa VisibleString OPTIONAL
}


CtermExtension ::= SEQUENCE {
    refStop INTEGER, 
    newAa VisibleString,
    length Count 
}


Frameshift ::= CHOICE {
    aasite AaSite,
    stopcodon NULL
}


Deletion ::= SEQUENCE { 
    loc SeqLocation,
    raw-seq VisibleString OPTIONAL -- can optionally specify the deleted sequence
}


Duplication ::= SEQUENCE {
    loc SeqLocation,
    raw-seq VisibleString OPTIONAL -- can optionally specify the sequence duplicated sequence
}


Inversion ::= SEQUENCE {
    ntint NtInterval,
    raw-seq VisibleString OPTIONAL,
    size  INTEGER OPTIONAL -- optionall specify the size of the inverted sequence
}


Insertion ::= SEQUENCE {
    int SeqInterval,

    seqinfo CHOICE {
        identifier VisibleString, -- A sequence identifier (e.g. an accession id)
        raw-seq VisibleString, -- The actual nucleotide / amino-acid sequence
        count Count, -- The number of elements inserted
        subseq Subsequence -- A subsequence specified by an id, type descriptor, and a range
    }
}


Conversion ::= SEQUENCE {
    loc NtLocation,
    origin NtLocation
}


Subsequence ::= SEQUENCE {
    identifier VisibleString, -- For example, an accession id
    type VariantSeqType,
    int SeqInterval
}


Repeat ::= SEQUENCE {
    loc SeqLocation,
    count Count,
    raw-seq VisibleString OPTIONAL --Used if ntloc is a site, not an interval
}


SeqLocation ::= CHOICE {
    aaloc AaLocation,
    ntloc NtLocation
}

SeqInterval ::= CHOICE {
    aaint AaInterval,
    ntint NtInterval
}


AaLocation ::= CHOICE {
    site AaSite,
    range AaSiteRange,
    int AaInterval
}


AaInterval ::= SEQUENCE {
    start AaSite,
    stop AaSite
}


AaSiteRange ::= SEQUENCE {
    start AaSite,
    stop  AaSite
}


    AaSite ::= SEQUENCE {
        index INTEGER,
        aa VisibleString
    }


    NtLocation ::= CHOICE {
        site NtSite,
        range NtSiteRange,
        int NtInterval
    }


    NtIntLimit ::= CHOICE {
        site NtSite,
        range NtSiteRange
    }

    NtInterval ::= SEQUENCE {
        start NtIntLimit,
        stop NtIntLimit
    }


    NtSiteRange ::= SEQUENCE {
        start NtSite,
        stop  NtSite
    }


    NtSite ::= SEQUENCE {
        seqid VisibleString OPTIONAL,
        seqtype VariantSeqType OPTIONAL,

        base CHOICE {
            val INTEGER,
            unknown NULL 
        },

        offset CHOICE {
            val INTEGER,
            plus-unknown NULL,
            minus-unknown NULL
        } OPTIONAL,

        utr CHOICE {
            five-prime NULL,
            three-prime NULL
        } OPTIONAL,


        strand-minus BOOLEAN DEFAULT FALSE, -- TRUE implies opposite transcriptional orientation to 
                                                -- to the reference sequence
        fuzzy BOOLEAN DEFAULT FALSE, -- TRUE implies HGVS subexpression of the form (base + offset),
        fuzzy-offset BOOLEAN DEFAULT FALSE -- TRUE implies HGVS subexpression of the form base+(offset)
    }


    Count ::= CHOICE {
        unknown NULL,
        val INTEGER,
        fuzzy-val INTEGER,
        range SEQUENCE { 
            start CHOICE {
                val INTEGER,
                unknown NULL   
            },
            stop CHOICE {
                val INTEGER,
                unknown NULL
            }
        }
    }

    END