fhirkit 0.1.0

// @generated by fhirkit-gen from hl7.fhir.r4.core 4.0.1. Do not edit.
//! The FHIR R4 `MolecularSequence` resource.

#![allow(
    unused_imports,
    clippy::large_enum_variant,
    clippy::too_many_lines,
    clippy::doc_markdown
)]

use crate::decode::{
    choice_key, required, required_list, resource_type, Choice, Decoder, FhirJson, Obj, ObjWriter,
};
use crate::json::Json;
use crate::primitive::{Decimal, Kind, Primitive};
use crate::r4::*;

/// Raw data describing a biological sequence.
///
/// FHIR path: `MolecularSequence`.
#[cfg(feature = "clinical")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct MolecularSequence {
    /// `id` (0..1): Logical id of this artifact
    pub id: Option<String>,
    /// `meta` (0..1): Metadata about the resource
    pub meta: Option<Meta>,
    /// `implicitRules` (0..1): A set of rules under which this content was created
    pub implicit_rules: Option<Primitive<String>>,
    /// `language` (0..1): Language of the resource content
    pub language: Option<Primitive<String>>,
    /// `text` (0..1): Text summary of the resource, for human interpretation
    pub text: Option<Narrative>,
    /// `contained` (0..*): Contained, inline Resources
    pub contained: Vec<Resource>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored
    pub modifier_extension: Vec<Extension>,
    /// `identifier` (0..*): Unique ID for this particular sequence. This is a FHIR-defined id
    pub identifier: Vec<Identifier>,
    /// `type` (0..1): aa | dna | rna
    pub type_: Option<Primitive<String>>,
    /// `coordinateSystem` (1..1): Base number of coordinate system (0 for 0-based numbering or coordinates, inclusive start, exclusive end, 1 for 1-based numbering, inclusive start, inclusive end)
    pub coordinate_system: Option<Primitive<i32>>,
    /// `patient` (0..1): Who and/or what this is about
    pub patient: Option<Reference>,
    /// `specimen` (0..1): Specimen used for sequencing
    pub specimen: Option<Reference>,
    /// `device` (0..1): The method for sequencing
    pub device: Option<Reference>,
    /// `performer` (0..1): Who should be responsible for test result
    pub performer: Option<Reference>,
    /// `quantity` (0..1): The number of copies of the sequence of interest. (RNASeq)
    pub quantity: Option<Quantity>,
    /// `referenceSeq` (0..1): A sequence used as reference
    pub reference_seq: Option<MolecularSequenceReferenceSeq>,
    /// `variant` (0..*): Variant in sequence
    pub variant: Vec<MolecularSequenceVariant>,
    /// `observedSeq` (0..1): Sequence that was observed
    pub observed_seq: Option<Primitive<String>>,
    /// `quality` (0..*): An set of value as quality of sequence
    pub quality: Vec<MolecularSequenceQuality>,
    /// `readCoverage` (0..1): Average number of reads representing a given nucleotide in the reconstructed sequence
    pub read_coverage: Option<Primitive<i32>>,
    /// `repository` (0..*): External repository which contains detailed report related with observedSeq in this resource
    pub repository: Vec<MolecularSequenceRepository>,
    /// `pointer` (0..*): Pointer to next atomic sequence
    pub pointer: Vec<Reference>,
    /// `structureVariant` (0..*): Structural variant
    pub structure_variant: Vec<MolecularSequenceStructureVariant>,
}

#[cfg(feature = "clinical")]
impl FhirJson for MolecularSequence {
    const TYPE_NAME: &'static str = "MolecularSequence";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        resource_type(&mut o, d, "MolecularSequence");
        let r = MolecularSequence {
            id: o.string(d, "id"),
            meta: o.one(d, "meta"),
            implicit_rules: o.prim(d, "implicitRules", Kind::Uri),
            language: o.prim(d, "language", Kind::Code),
            text: o.one(d, "text"),
            contained: o.list(d, "contained"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            identifier: o.list(d, "identifier"),
            type_: o.prim(d, "type", Kind::Code),
            coordinate_system: o.prim(d, "coordinateSystem", Kind::Integer),
            patient: o.one(d, "patient"),
            specimen: o.one(d, "specimen"),
            device: o.one(d, "device"),
            performer: o.one(d, "performer"),
            quantity: o.one(d, "quantity"),
            reference_seq: o.one(d, "referenceSeq"),
            variant: o.list(d, "variant"),
            observed_seq: o.prim(d, "observedSeq", Kind::String),
            quality: o.list(d, "quality"),
            read_coverage: o.prim(d, "readCoverage", Kind::Integer),
            repository: o.list(d, "repository"),
            pointer: o.list(d, "pointer"),
            structure_variant: o.list(d, "structureVariant"),
        };
        required(d, "coordinateSystem", &r.coordinate_system);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.raw("resourceType", Json::String("MolecularSequence".into()));
        w.string("id", &self.id);
        w.one("meta", &self.meta);
        w.prim("implicitRules", &self.implicit_rules);
        w.prim("language", &self.language);
        w.one("text", &self.text);
        w.list("contained", &self.contained);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.list("identifier", &self.identifier);
        w.prim("type", &self.type_);
        w.prim("coordinateSystem", &self.coordinate_system);
        w.one("patient", &self.patient);
        w.one("specimen", &self.specimen);
        w.one("device", &self.device);
        w.one("performer", &self.performer);
        w.one("quantity", &self.quantity);
        w.one("referenceSeq", &self.reference_seq);
        w.list("variant", &self.variant);
        w.prim("observedSeq", &self.observed_seq);
        w.list("quality", &self.quality);
        w.prim("readCoverage", &self.read_coverage);
        w.list("repository", &self.repository);
        w.list("pointer", &self.pointer);
        w.list("structureVariant", &self.structure_variant);
        w.finish()
    }
}

/// A sequence used as reference
///
/// FHIR path: `MolecularSequence.referenceSeq`.
#[cfg(feature = "clinical")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct MolecularSequenceReferenceSeq {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `chromosome` (0..1): Chromosome containing genetic finding
    pub chromosome: Option<CodeableConcept>,
    /// `genomeBuild` (0..1): The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'
    pub genome_build: Option<Primitive<String>>,
    /// `orientation` (0..1): sense | antisense
    pub orientation: Option<Primitive<String>>,
    /// `referenceSeqId` (0..1): Reference identifier
    pub reference_seq_id: Option<CodeableConcept>,
    /// `referenceSeqPointer` (0..1): A pointer to another MolecularSequence entity as reference sequence
    pub reference_seq_pointer: Option<Reference>,
    /// `referenceSeqString` (0..1): A string to represent reference sequence
    pub reference_seq_string: Option<Primitive<String>>,
    /// `strand` (0..1): watson | crick
    pub strand: Option<Primitive<String>>,
    /// `windowStart` (0..1): Start position of the window on the reference sequence
    pub window_start: Option<Primitive<i32>>,
    /// `windowEnd` (0..1): End position of the window on the reference sequence
    pub window_end: Option<Primitive<i32>>,
}

#[cfg(feature = "clinical")]
impl FhirJson for MolecularSequenceReferenceSeq {
    const TYPE_NAME: &'static str = "MolecularSequenceReferenceSeq";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = MolecularSequenceReferenceSeq {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            chromosome: o.one(d, "chromosome"),
            genome_build: o.prim(d, "genomeBuild", Kind::String),
            orientation: o.prim(d, "orientation", Kind::Code),
            reference_seq_id: o.one(d, "referenceSeqId"),
            reference_seq_pointer: o.one(d, "referenceSeqPointer"),
            reference_seq_string: o.prim(d, "referenceSeqString", Kind::String),
            strand: o.prim(d, "strand", Kind::Code),
            window_start: o.prim(d, "windowStart", Kind::Integer),
            window_end: o.prim(d, "windowEnd", Kind::Integer),
        };
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.one("chromosome", &self.chromosome);
        w.prim("genomeBuild", &self.genome_build);
        w.prim("orientation", &self.orientation);
        w.one("referenceSeqId", &self.reference_seq_id);
        w.one("referenceSeqPointer", &self.reference_seq_pointer);
        w.prim("referenceSeqString", &self.reference_seq_string);
        w.prim("strand", &self.strand);
        w.prim("windowStart", &self.window_start);
        w.prim("windowEnd", &self.window_end);
        w.finish()
    }
}

/// Variant in sequence
///
/// FHIR path: `MolecularSequence.variant`.
#[cfg(feature = "clinical")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct MolecularSequenceVariant {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `start` (0..1): Start position of the variant on the reference sequence
    pub start: Option<Primitive<i32>>,
    /// `end` (0..1): End position of the variant on the reference sequence
    pub end: Option<Primitive<i32>>,
    /// `observedAllele` (0..1): Allele that was observed
    pub observed_allele: Option<Primitive<String>>,
    /// `referenceAllele` (0..1): Allele in the reference sequence
    pub reference_allele: Option<Primitive<String>>,
    /// `cigar` (0..1): Extended CIGAR string for aligning the sequence with reference bases
    pub cigar: Option<Primitive<String>>,
    /// `variantPointer` (0..1): Pointer to observed variant information
    pub variant_pointer: Option<Reference>,
}

#[cfg(feature = "clinical")]
impl FhirJson for MolecularSequenceVariant {
    const TYPE_NAME: &'static str = "MolecularSequenceVariant";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = MolecularSequenceVariant {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            start: o.prim(d, "start", Kind::Integer),
            end: o.prim(d, "end", Kind::Integer),
            observed_allele: o.prim(d, "observedAllele", Kind::String),
            reference_allele: o.prim(d, "referenceAllele", Kind::String),
            cigar: o.prim(d, "cigar", Kind::String),
            variant_pointer: o.one(d, "variantPointer"),
        };
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("start", &self.start);
        w.prim("end", &self.end);
        w.prim("observedAllele", &self.observed_allele);
        w.prim("referenceAllele", &self.reference_allele);
        w.prim("cigar", &self.cigar);
        w.one("variantPointer", &self.variant_pointer);
        w.finish()
    }
}

/// An set of value as quality of sequence
///
/// FHIR path: `MolecularSequence.quality`.
#[cfg(feature = "clinical")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct MolecularSequenceQuality {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `type` (1..1): indel | snp | unknown
    pub type_: Option<Primitive<String>>,
    /// `standardSequence` (0..1): Standard sequence for comparison
    pub standard_sequence: Option<CodeableConcept>,
    /// `start` (0..1): Start position of the sequence
    pub start: Option<Primitive<i32>>,
    /// `end` (0..1): End position of the sequence
    pub end: Option<Primitive<i32>>,
    /// `score` (0..1): Quality score for the comparison
    pub score: Option<Quantity>,
    /// `method` (0..1): Method to get quality
    pub method: Option<CodeableConcept>,
    /// `truthTP` (0..1): True positives from the perspective of the truth data
    pub truth_tp: Option<Primitive<Decimal>>,
    /// `queryTP` (0..1): True positives from the perspective of the query data
    pub query_tp: Option<Primitive<Decimal>>,
    /// `truthFN` (0..1): False negatives
    pub truth_fn: Option<Primitive<Decimal>>,
    /// `queryFP` (0..1): False positives
    pub query_fp: Option<Primitive<Decimal>>,
    /// `gtFP` (0..1): False positives where the non-REF alleles in the Truth and Query Call Sets match
    pub gt_fp: Option<Primitive<Decimal>>,
    /// `precision` (0..1): Precision of comparison
    pub precision: Option<Primitive<Decimal>>,
    /// `recall` (0..1): Recall of comparison
    pub recall: Option<Primitive<Decimal>>,
    /// `fScore` (0..1): F-score
    pub f_score: Option<Primitive<Decimal>>,
    /// `roc` (0..1): Receiver Operator Characteristic (ROC) Curve
    pub roc: Option<MolecularSequenceQualityRoc>,
}

#[cfg(feature = "clinical")]
impl FhirJson for MolecularSequenceQuality {
    const TYPE_NAME: &'static str = "MolecularSequenceQuality";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = MolecularSequenceQuality {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            type_: o.prim(d, "type", Kind::Code),
            standard_sequence: o.one(d, "standardSequence"),
            start: o.prim(d, "start", Kind::Integer),
            end: o.prim(d, "end", Kind::Integer),
            score: o.one(d, "score"),
            method: o.one(d, "method"),
            truth_tp: o.prim(d, "truthTP", Kind::Decimal),
            query_tp: o.prim(d, "queryTP", Kind::Decimal),
            truth_fn: o.prim(d, "truthFN", Kind::Decimal),
            query_fp: o.prim(d, "queryFP", Kind::Decimal),
            gt_fp: o.prim(d, "gtFP", Kind::Decimal),
            precision: o.prim(d, "precision", Kind::Decimal),
            recall: o.prim(d, "recall", Kind::Decimal),
            f_score: o.prim(d, "fScore", Kind::Decimal),
            roc: o.one(d, "roc"),
        };
        required(d, "type", &r.type_);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("type", &self.type_);
        w.one("standardSequence", &self.standard_sequence);
        w.prim("start", &self.start);
        w.prim("end", &self.end);
        w.one("score", &self.score);
        w.one("method", &self.method);
        w.prim("truthTP", &self.truth_tp);
        w.prim("queryTP", &self.query_tp);
        w.prim("truthFN", &self.truth_fn);
        w.prim("queryFP", &self.query_fp);
        w.prim("gtFP", &self.gt_fp);
        w.prim("precision", &self.precision);
        w.prim("recall", &self.recall);
        w.prim("fScore", &self.f_score);
        w.one("roc", &self.roc);
        w.finish()
    }
}

/// Receiver Operator Characteristic (ROC) Curve
///
/// FHIR path: `MolecularSequence.quality.roc`.
#[cfg(feature = "clinical")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct MolecularSequenceQualityRoc {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `score` (0..*): Genotype quality score
    pub score: Vec<Primitive<i32>>,
    /// `numTP` (0..*): Roc score true positive numbers
    pub num_tp: Vec<Primitive<i32>>,
    /// `numFP` (0..*): Roc score false positive numbers
    pub num_fp: Vec<Primitive<i32>>,
    /// `numFN` (0..*): Roc score false negative numbers
    pub num_fn: Vec<Primitive<i32>>,
    /// `precision` (0..*): Precision of the GQ score
    pub precision: Vec<Primitive<Decimal>>,
    /// `sensitivity` (0..*): Sensitivity of the GQ score
    pub sensitivity: Vec<Primitive<Decimal>>,
    /// `fMeasure` (0..*): FScore of the GQ score
    pub f_measure: Vec<Primitive<Decimal>>,
}

#[cfg(feature = "clinical")]
impl FhirJson for MolecularSequenceQualityRoc {
    const TYPE_NAME: &'static str = "MolecularSequenceQualityRoc";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = MolecularSequenceQualityRoc {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            score: o.prim_list(d, "score", Kind::Integer),
            num_tp: o.prim_list(d, "numTP", Kind::Integer),
            num_fp: o.prim_list(d, "numFP", Kind::Integer),
            num_fn: o.prim_list(d, "numFN", Kind::Integer),
            precision: o.prim_list(d, "precision", Kind::Decimal),
            sensitivity: o.prim_list(d, "sensitivity", Kind::Decimal),
            f_measure: o.prim_list(d, "fMeasure", Kind::Decimal),
        };
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim_list("score", &self.score);
        w.prim_list("numTP", &self.num_tp);
        w.prim_list("numFP", &self.num_fp);
        w.prim_list("numFN", &self.num_fn);
        w.prim_list("precision", &self.precision);
        w.prim_list("sensitivity", &self.sensitivity);
        w.prim_list("fMeasure", &self.f_measure);
        w.finish()
    }
}

/// External repository which contains detailed report related with observedSeq in this resource
///
/// FHIR path: `MolecularSequence.repository`.
#[cfg(feature = "clinical")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct MolecularSequenceRepository {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `type` (1..1): directlink | openapi | login | oauth | other
    pub type_: Option<Primitive<String>>,
    /// `url` (0..1): URI of the repository
    pub url: Option<Primitive<String>>,
    /// `name` (0..1): Repository's name
    pub name: Option<Primitive<String>>,
    /// `datasetId` (0..1): Id of the dataset that used to call for dataset in repository
    pub dataset_id: Option<Primitive<String>>,
    /// `variantsetId` (0..1): Id of the variantset that used to call for variantset in repository
    pub variantset_id: Option<Primitive<String>>,
    /// `readsetId` (0..1): Id of the read
    pub readset_id: Option<Primitive<String>>,
}

#[cfg(feature = "clinical")]
impl FhirJson for MolecularSequenceRepository {
    const TYPE_NAME: &'static str = "MolecularSequenceRepository";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = MolecularSequenceRepository {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            type_: o.prim(d, "type", Kind::Code),
            url: o.prim(d, "url", Kind::Uri),
            name: o.prim(d, "name", Kind::String),
            dataset_id: o.prim(d, "datasetId", Kind::String),
            variantset_id: o.prim(d, "variantsetId", Kind::String),
            readset_id: o.prim(d, "readsetId", Kind::String),
        };
        required(d, "type", &r.type_);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("type", &self.type_);
        w.prim("url", &self.url);
        w.prim("name", &self.name);
        w.prim("datasetId", &self.dataset_id);
        w.prim("variantsetId", &self.variantset_id);
        w.prim("readsetId", &self.readset_id);
        w.finish()
    }
}

/// Structural variant
///
/// FHIR path: `MolecularSequence.structureVariant`.
#[cfg(feature = "clinical")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct MolecularSequenceStructureVariant {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `variantType` (0..1): Structural variant change type
    pub variant_type: Option<CodeableConcept>,
    /// `exact` (0..1): Does the structural variant have base pair resolution breakpoints?
    pub exact: Option<Primitive<bool>>,
    /// `length` (0..1): Structural variant length
    pub length: Option<Primitive<i32>>,
    /// `outer` (0..1): Structural variant outer
    pub outer: Option<MolecularSequenceStructureVariantOuter>,
    /// `inner` (0..1): Structural variant inner
    pub inner: Option<MolecularSequenceStructureVariantInner>,
}

#[cfg(feature = "clinical")]
impl FhirJson for MolecularSequenceStructureVariant {
    const TYPE_NAME: &'static str = "MolecularSequenceStructureVariant";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = MolecularSequenceStructureVariant {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            variant_type: o.one(d, "variantType"),
            exact: o.prim(d, "exact", Kind::Boolean),
            length: o.prim(d, "length", Kind::Integer),
            outer: o.one(d, "outer"),
            inner: o.one(d, "inner"),
        };
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.one("variantType", &self.variant_type);
        w.prim("exact", &self.exact);
        w.prim("length", &self.length);
        w.one("outer", &self.outer);
        w.one("inner", &self.inner);
        w.finish()
    }
}

/// Structural variant outer
///
/// FHIR path: `MolecularSequence.structureVariant.outer`.
#[cfg(feature = "clinical")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct MolecularSequenceStructureVariantOuter {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `start` (0..1): Structural variant outer start
    pub start: Option<Primitive<i32>>,
    /// `end` (0..1): Structural variant outer end
    pub end: Option<Primitive<i32>>,
}

#[cfg(feature = "clinical")]
impl FhirJson for MolecularSequenceStructureVariantOuter {
    const TYPE_NAME: &'static str = "MolecularSequenceStructureVariantOuter";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = MolecularSequenceStructureVariantOuter {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            start: o.prim(d, "start", Kind::Integer),
            end: o.prim(d, "end", Kind::Integer),
        };
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("start", &self.start);
        w.prim("end", &self.end);
        w.finish()
    }
}

/// Structural variant inner
///
/// FHIR path: `MolecularSequence.structureVariant.inner`.
#[cfg(feature = "clinical")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct MolecularSequenceStructureVariantInner {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `start` (0..1): Structural variant inner start
    pub start: Option<Primitive<i32>>,
    /// `end` (0..1): Structural variant inner end
    pub end: Option<Primitive<i32>>,
}

#[cfg(feature = "clinical")]
impl FhirJson for MolecularSequenceStructureVariantInner {
    const TYPE_NAME: &'static str = "MolecularSequenceStructureVariantInner";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = MolecularSequenceStructureVariantInner {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            start: o.prim(d, "start", Kind::Integer),
            end: o.prim(d, "end", Kind::Integer),
        };
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("start", &self.start);
        w.prim("end", &self.end);
        w.finish()
    }
}